Sitzung 04
Rust und Agentic Development
Mit Matthias Endler, Rust Consultant, corrode

Worum es geht
Shownotes
Kurz gesagt: In dieser Folge von Token Therapie sprechen Jan Schulte und Dr. Michael Köpf mit Matthias Endler, Rust Consultant bei corrode und Host des Podcasts „Rust in Production“, über Rust und agentische Softwareentwicklung. Seine Kernaussage: KI-generierter Code spart nur dann Zeit, wenn das Team ihn versteht – gemeinsame mentale Modelle, gründliche Reviews und besseres Review-Tooling sind wichtiger als die Menge des erzeugten Codes.
Das Wichtigste in Kürze
- Wer wenig Rust-Erfahrung hat, schreibt dem Modell oft zu viel Kompetenz zu; der Code wird dann nicht so gründlich reviewt, wie er sollte.
- Technische Schulden aus generiertem Code zeigen sich laut Matthias Endler oft erst nach drei bis sechs Monaten.
- Gegen „Comprehension Debt“ helfen Gespräche, Skizzen in Excalidraw, Domain-Driven Design und kurze Markdown-Dokumente; am Anfang kostet das Zeit, am Ende spart es Zeit.
- 70 bis 80 Prozent seiner Arbeitszeit sind Reviews; textbasierte Git-Diffs sind für große Änderungen der Engpass.
- Rust beantwortet viele Fragen schon zur Compilezeit, löst aber keine Fehler in der Business-Logik.
- Mehr generierter Code heißt nicht weniger Wartung: Je mehr Code, desto teurer werden Refactorings.
- Teams standardisieren sich weniger wegen der Sprache als wegen des ganzen Ökosystems aus CI/CD, Deployment, Logging, Monitoring und geprüften Libraries.
Warum ist KI-generierter Rust-Code ein Risiko für Teams?
Matthias Endler beschreibt sich als eher konservativ im Umgang mit Large Language Models. Er sieht sie als Werkzeug, das für Codegenerierung, Prototypen und Experimente sehr gut ist. Das Problem liegt für ihn bei Menschen mit wenig Rust-Erfahrung, die „dem Modell zu viel Kompetenz zusprechen“.
Sie wirken mit den Code-Generierungs-Tools schneller, sollten die gewonnene Zeit aber zum Nachdenken, Reflektieren und für Pair Programming nutzen. Software im Großen ist für Endler eine Unterhaltung zwischen Menschen, in der jeder ein mentales Modell von Produkt und Architektur aufbaut. Michael Köpf nennt das Risiko, dass dieses Modell nicht mehr mitkommt, Cognitive Debt oder Comprehension Debt: Der Code läuft den Entwicklern davon.
Für Teamleads empfiehlt Endler, Vertrauen in Methoden zu haben, die die Debt früh sichtbar machen, weil sie sonst erst nach Monaten auffällt:
- in Meetings klären und in Excalidraw zeichnen, ob alle dasselbe mentale Modell haben;
- mit Domain-Driven Design (DDD) die Elemente und Komponenten der Domäne und das Datenmodell beschreiben, am Whiteboard oder in einer Textdatei;
- Wissenslücken und Gefahren im mentalen Modell gemeinsam suchen, im Team und mit Agenten.
Das funktioniert laut Endler mit Rust besonders gut, weil die Sprache von Anfang an verlangt, dass man weiß, wie die Komponenten miteinander sprechen.
Wie sollte Review-Tooling für viel generierten Code aussehen?
Jan Schulte fragt, wie man Änderungen von 100.000 Zeilen noch über einen klassischen Git-Diff reviewen soll. Matthias Endler sieht eine Diskrepanz im Tooling: Agentische Systeme erzeugen viel mehr Code, aber es gibt wenige solide Review-Tools, die skalieren. Große Änderungen auf Textbasis zu analysieren, skaliert schlecht.
Er wünscht sich ein Werkzeug wie eine IDE, in der man zwischen Ebenen wechselt: vom Diff auf Textebene mit einem Klick zum Klassendiagramm, dann zu einem agentischen Review. Die Aufmerksamkeit soll auf den Hotspots liegen statt auf Tippfehlern: Performance, Sicherheit, aktuelle Kommentare und Dokumentation, unbehandelte Fehlerfälle. Sein Fazit: „wir sind, was das Tooling angeht, so ein bisschen in den 90ern hängen geblieben“.
Michael Köpf fragt nach der Eingabeseite, nach Spec Driven Development und dem früheren Model Driven Development. Endler kennt modellgetriebene Systeme aus seiner Unizeit. Damals fehlte das Vokabular, um auszudrücken, wie der Code aussehen soll; der erzeugte Code war nur für Maschinen gedacht, zu lang, und die Tools waren langsam. Ein neuer Anlauf bräuchte leichteres, interaktives Tooling und eine Antwort auf die Frage, wie viel man selbst macht und wie viel deklarativ.
Was lehrt der KI-getriebene Rewrite von Bun von Zig nach Rust?
Jan Schulte nennt Zahlen zum Rewrite von Bun durch Jarred Sumner: innerhalb von 11 Tagen über eine halbe Million Lines of Code nach Rust portiert, in der Spitze 700 Commits pro Stunde, zum Großteil per KI, mit geschätzt etwa 170.000 Dollar API-Kosten.
Matthias Endler warnt davor, eine große Codebase vollautomatisch umschreiben zu lassen. Rust beantwortet viele Fragen schon zur Compilezeit, etwa Dateigröße, Encoding und Zugriffsrechte beim Lesen einer Datei. Aber: „Rust löst keine Business Logik Probleme“. Auch in Rust führt ein Slice-Operator mit einem Index, den es im String nicht gibt, zu einer Panic.
Bei Bun gab es laut Endler schon vorher Anzeichen, dass der Code kein idiomatisches Zig war; nach einer Migration hat man ähnliche Probleme in der anderen Sprache. Die erste Version des Rewrites war seiner Ansicht nach nicht idiomatisch, und „Code an sich ist auch nicht billig“: Je mehr Code generiert ist, desto teurer werden Refactoring und größere Umstellungen. Sein Satz dazu: „schlechter Code macht KI Vorteile zunichte“. Fairerweise sagt er auch, dass sich der Code von Bun in den Wochen danach stark verbessert hat.
Lohnt es sich noch, Rust und Programmieren gründlich zu lernen?
Matthias Endler lernte mit Büchern und dem Basic-Editor von Windows 95. Er glaubt, dass Neugier auf Systeme einen zwangsläufig zu Sprachen, Hardware und Architektur führt. Heute kennt er junge Menschen, die rein agentisch beeindruckende Dinge bauen, etwa ein Computerspiel, das an Stardew Valley erinnert, ohne Bezug zum Code. Den Übergang vergleicht er mit dem von Assembly zu C.
Er rät jedem, Dinge auszuprobieren. Systeme müssen gewartet werden, und jemand muss wissen, wie eine Sandbox, eine Harness oder eine VM funktioniert. KI erleichtert den Einstieg und lässt auch Erfahrene tiefer gehen, etwa einen Kernel-Treiber, einen Konsolen-Emulator oder eine eigene Programmiersprache bauen. Er selbst schrieb eine iOS-App in Swift, ohne Swift zu können.
Für Unternehmen empfiehlt er, neue Sprachen mit einem schnell gebauten Prototypen zu erproben, etwa auf einem Prozent des Traffics, statt nur im Kämmerchen zu überlegen. Bei neuen Sprachen haben LLMs laut Endler ein Problem: Der Trainingskorpus besteht aus ähnlichen, eher imperativen und objektorientierten Sprachen, und Modelle fügen Code eher hinzu, als ihn zu refaktorieren. Neue Sprachen sollten deshalb eine Spezifikation, einen MCP-Server oder eine Vektorsuche mitliefern, ähnlich wie Context7 es für Libraries tut.
Häufige Fragen
Was ist Comprehension Debt?
Comprehension Debt (auch Cognitive Debt) beschreibt, dass KI-generierter Code schneller wächst, als Entwicklerinnen und Entwickler ihr mentales Modell davon aktuell halten können. Matthias Endler setzt dagegen Gespräche, Diagramme, Dokumentation und Domain-Driven Design.
Macht Rust KI-generierten Code sicher?
Nein, nicht vollständig. Rust erzwingt viele Entscheidungen zur Compilezeit, aber Fehler in der Business-Logik bleiben, und auch Rust-Programme können abstürzen, etwa durch einen ungültigen Index in einem String.
Sollte man eine große Codebase per KI in eine andere Sprache portieren?
Matthias Endler hält eine vollautomatische Umschreibung für gefährlich. Ein Sprachwechsel löst keine Probleme in Logik oder Architektur, und mehr generierter Code macht spätere Refactorings teurer.
Wie reviewt man große KI-generierte Änderungen?
Laut Matthias Endler skalieren textbasierte Git-Diffs dafür schlecht. Er wünscht sich Tools, die zwischen Text, Klassendiagramm und agentischem Review wechseln und den Blick auf Hotspots wie Sicherheit, Performance und unbehandelte Fehlerfälle lenken.
Kommen LLMs mit neuen Programmiersprachen zurecht?
Nur mit Hilfe, meint Matthias Endler, weil der Trainingskorpus aus ähnlichen Sprachen besteht. Neue Sprachen sollten Spezifikation und Tooling wie einen MCP-Server oder eine Vektorsuche mitliefern, damit Modelle sie lernen können.
Welche Tipps gibt Matthias Endler für KI in der Rust-Entwicklung?
Er rät, die Vorteile von KI im Alltag zu nutzen, ohne sich zu verschließen oder blauäugig zu sein, und weiter ein Verständnis von Systemen und Sprachen aufzubauen. Dazu Methoden wie DDD und testgetriebenes Design (Test-driven Design), Composition statt Inheritance und vorhandene Werkzeuge wie Formatter und Linter.
Links
- Matthias Endler: LinkedIn
- corrode: corrode.dev
Direkt zum Thema
Kapitel
- 00:00Begrüßung und GastTranskript
- 01:05KI Code RisikenTranskript
- 04:05Teamprozesse gegen DebtTranskript
- 07:36Review Tooling ZukunftTranskript
- 10:38Spec und Model DrivenTranskript
- 13:50Rust Komplexität erklärtTranskript
- 14:19Bun Rewrite EinordnungTranskript
- 20:01Lernen im Agenten ZeitalterTranskript
- 27:00Polyglot Teams und EcosystemTranskript
- 31:37Zukunft der SprachenTranskript
- 35:34LLMs und neue SprachenTranskript
- 40:31Abschluss und TippsTranskript
Nachlesen
Transkript
Transkript anzeigenTranskript ausblenden
Jan Schulte
Willkommen bei Token Therapie, dem Podcast für AI Engineering Leader. Mein Name ist Jan und mit dabei wie immer Michael. Hallo Anderserseits. Unser heutiges Thema ist Rust und AI Agents oder Agentic AI und dazu haben wir uns Matthias Endler eingeladen. Matthias ist Rust Consultant und Host des berühmten Rust in Production Podcasts. Matthias, schön, dass du da bist.
Matthias Endler
Danke für die Einladung.
Jan Schulte
Matthias, vielleicht kannst du dich ganz kurz vorstellen, kurz erzählen, was du so machst.
Matthias Endler
Ja, ich habe einen Computer Science Hintergrund, habe einen Master und habe dann angefangen zu arbeiten als Backend Ingenieur in Düsseldorf bei einer Firma namens Trivago. Habe mich dann vor paar Jahren selbständig gemacht im Rustbereich. bin schon sehr lange in der Community aktiv, schon seit der Version 1.0 oder ein bisschen davor und berate Kunden zur Anwendung von Rust in Produktion.
Dr. Michael Köpf
Ja, jetzt wird ja sicherlich ähm auch äh bei dir agentische Softwareentwicklung in den letzten Jahren extrem wichtig geworden sein. Ich habe vielleicht als Einstiegsfrage, bist du mittlerweile schon Token Maxer oder bist du noch jemand, der wirklich noch jede jede Zeile reviewt oder irgendwo dazwischen?
Matthias Endler
Ja, also ich bin schon äh tatsächlich eher konservativ, was das Thema angeht, muss ich zugeben. Natürlich kenne ich die Vorteile von AI und ähm glaube auch, dass ich ein paar Sachen darüber gelernt habe, wie man vielleicht solche Modelle auch einsetzt. Aber so generell würde ich jetzt mal behaupten, ist es hilfreich, wenn man auch versteht, was ähm da passiert und wenn man vielleicht noch die Möglichkeit hat, auch selber zu intervenieren oder möglicherweise auch selber Code zu schreiben.
Jan Schulte
Welche Probleme siehst du aktuell bei KI generiertem Code speziell auch im Bezug mit Rust?
Matthias Endler
Ich sehe es eher als Tool als KI. Also den Begriff an sich mag ich nicht so gern, muss ich sagen. Ich glaube eher ein Large Language Model dürft's vielleicht eher und für mich ist es so, dass es für Code Generierung schon sehr gut ist und für Prototyping und für Experimente. Was ich allerdings schon beobachte ist, dass manche Leute, die vielleicht noch nicht so viel Erfahrung mit Rust haben, dem Modell zu viel Kompetenz zusprechen. Und das führt dazu, dass der Code vielleicht in Grisel Teams nicht zu reviewed wird, wie er vielleicht reviewed werden sollte und dass vielleicht manche Leute im Team dann augenscheinlich ein bisschen schneller sind mit diesen Modellen, mit diesen Code Generationstools, aber vielleicht im Nachhinein eher die Zeit verwenden sollten ein bisschen mehr drüber nachzudenken und zu reflektieren und vielleicht auch mit Pairprogramming und mit anderen Leuten zusammen den Code zu besprechen, weil das ist ist letztendlich was es ausmacht, wenn man Software im großen schreibt, dass das mehr oder weniger eine Unterhaltung zwischen Menschen ist und dass jeder ein mentales Modell aufbaut davon, was eigentlich bei dem Produkt passiert und architekturell auch passiert.
Dr. Michael Köpf
Ja, also das finde ich einen extrem wichtigen Punkt. Also einige nennen das ja jetzt mittlerweile Cognitive Debt oder auch Comprehension Debt, was du ansprichst. Also praktisch, dass der der Code eigentlich den Entwicklern davon läuft. Ja, man kommt gar nicht hinterher, das mentale Modell ähm aktuell zu halten. Ähm, also du hast gerade angesprochen, Pair Programming z.B. kann dagegen helfen. Welche anderen vielleicht systematischen Mittel würdest äh würdest du sehen, die man mit dem man diesem Problem dann ähm begegnen kann? Vor allem, wenn man jetzt an Team denkt, also sagen wir mal Teamlead oder sowas, ja, der jetzt fünf bis zehn Leute hat in seinem Team, die die jetzt auch agentisch entwickeln, wie kann der diesem Problem begegnen?
Matthias Endler
Genau. Also, ich glaube, es ist wichtig, dass man sich erstmal in diese Situation versetzt. Also, da ist jemand, der vielleicht auch den Code produktiv bringen muss und das Projekt auch vorantreiben muss. Und auf der anderen Seite sieht man vielleicht diese Technical Debt nicht sofort. Also die vielleicht kommt erst in drei bis sechs Monaten zum Vorschein und da ist es halt wichtig, dass man das Vertrauen hat und sagt, es ist trotzdem wichtig, dass man vorher genau weiß, was man tut, vielleicht auch kommuniziert, vielleicht auch entsprechende Lücken füllt im Team. Das kann man einfach ganz normal in Meetings machen durch Kommunikation oder vielleicht in Excalidraw mal was zeichnen und schauen, ob wirklich jeder dasselbe Verständnis hat, äh dasselbe mentale Modell hat von dem, was man baut. Das andere, was mir aufgefallen ist, BDD, also ähm na ja, Domain Driven Design äh funktioniert eigentlich auch sehr sehr gut. ähm, dass man vielleicht sagt, was sind die einzelnen Elemente, was sind die einzelnen Komponenten in meinem in meiner Domäne und wie modelliere ich die? Also das funktioniert halt besonders gut mit Rust, weil Rust halt eine Sprache ist, die sehr sehr viele Sachen von Anfang an von einem Entwickler verlangt. Also, dass man eben sich im klar ist, wie diese einzelnen Komponenten miteinander sprechen und so weiter und wie das Datenmodell aussieht und das kann man sehr sehr gut am Whiteboard oder vielleicht einfach in der Textdatei festhalten. Also was sind die einzelnen Teile und wie definiert man die und welche Funktion haben die? Dann tut man sich im Nachhinein viel viel leichter generell im Team, aber auch mit Agenten das zu kommunizieren und zu sagen, ah, okay, wo sind meine Wissenslücken und wo sind potenziell die Gefahren in diesem ähm mentalen Modell? Was muss ich noch ändern, damit sich das verbessert? Also eigentlich hat sich am Tooling nicht viel verändert, sondern man muss den Leuten eher die Zuversicht geben, solche Sachen auch einzusetzen und dann vielleicht auch mal derjenige sein, der sagt, man muss Vertrauen haben, dass das der richtige Weg ist und man hat das ja schon paar mal vorher auch gemacht mit Teams, dass man sich am Ende dann dadurch Zeit spart. Also klar hat man am Anfang mehr Arbeit und muss mehr dokumentieren, vielleicht auch mal eine Markdown-Datei schreiben oder ein Diagramm malen oder so, aber am Ende spart man sich die Zeit dann wieder. Ähm,
Jan Schulte
darauf will ich noch mal kurz kurz eingehen. Also Tooling, du hast jetzt schon gesagt, aus deiner Sicht hat sich jetzt noch nicht so viel an Tooling geändert. Ähm, was ich ganz spannend finde, ist ähm bisschen die andere Richtung Richtung halt diesen Reviewing, ähm wenn man dann halt irgendwann Code generiert hat. Ähm wie siehst du da, dass also wir sehen jetzt quasi, dass immer schneller immer mehr Code generiert wird, der Code natürlich auch besser wird. Natürlich gibt's noch immer äh immer viele Fehler und viele Probleme im Code. Ähm aber man merkt ja so, dass die Tendenz äh eher so in die Richtung geht, okay, es wird schneller mehr Code produziert und der langsam auch qualitativ einfach besser wird. Ähm wie siehst du das? Wie wie müsste da so quasi das ähm Tooling der Zukunft aussehen? Ähm speziell, wenn man irgendwann vielleicht nicht mehr in diese Situation kommt, äh wo man dann per AI mal ganz schnell irgendwie 100.000 Zeilen Code generiert hat und die dann einfach nicht mehr klassischen Git Diff irgendwie äh reviewen kann. Ähm was ist so da in der Meinung dazu?
Matthias Endler
Ja, äh kurz vorher noch mal, also ich glaube schon, dass sich am Tooling viel verändert hat. Ähm also die IDE und so weiter haben sich natürlich verändert und funktionieren auch jetzt bisschen anders als vorher, das ist klar. Was ich gemeint habe, ist zu dieser interaktive Teil zwischen Menschen hat sich nicht viel geändert. Also da muss man immer noch dieses gemeinsame Verständnis aufbauen und einfach verschiedene Rollen einnehmen in dem Projekt. Aber zu deiner Frage konkret, was jetzt Reviews angeht, ja, richtig. Also 70% meiner Zeit oder 80% meiner Zeit sind Reviews. Waren sie auch vorher schon, aber vielleicht jetzt sogar noch ein bisschen mehr. Und was ich feststelle ist, dass es da so eine extreme Diskrepanz gibt zwischen dem Tooling. Zum einen auf der Entwicklungsseite. Da haben wir natürlich jetzt über agentische Systeme viel mehr Möglichkeiten Code zu generieren, aber auf der anderen Seite haben wir wenige solide Tools für Code Reviews, die wirklich skalieren. Also sein auf Textbasis großen Change zu analysieren, skaliert halt schlecht und diese ganzen Modelle, die auf Gits funktionieren, die sind halt jetzt eigentlich der Bottleneck und das ist extrem problematisch, finde ich. Also vor allen Dingen, wenn man das beruflich macht. Was meine ich damit? Ich glaube, Text auf wirklich textueller, syntaktischer Ebene zu analysieren ist nur ein kleiner Teil der Aufgabe. Man muss eigentlich auch an die Semantik denken. Also z.B. wie sieht ein Klassendiagramm aus? Wie sind die Bindungen zwischen den einzelnen Komponenten? Und man will das vielleicht noch mehr abstrahieren und will sagen, okay, wo sind generell Bottlenecks auf der Performance Seite, auf der Sicherheitsseite, wo gibt's Probleme, die ich mir als Mensch anschauen muss und ich glaube, dass es in Zukunft eine große Aufgabe, dieses Tooling zu verbessern. Wie die wie das aussehen kann, weiß ich noch nicht, aber ich persönlich stell mir halt ein Tool vor wie eine IDE, mit der ich dann zwischen verschiedenen Ebenen wechseln kann. Also, ich kann mir jetzt beispiel schon auf der Textebene einen Diff anschauen, aber dann kann ich einfach mit einem Klick zu einem Klassendiagramm wechseln und dann kann ich mir vielleicht ein agentischen Review anschauen, also mit Assistenz Tools arbeiten und mich dann auf die wichtigen Sachen konzentrieren, vielleicht nicht auf Typos, weil es gibt eigentlich fast keine Typos mehr, wenn man das Tooling richtig einsetzt, sondern eher sind die Kommentare richtig geschrieben oder ist die Dokumentation angepasst oder finde ich vielleicht irgendwelche Fehlercases, die jetzt nicht behandelt werden? Wie kann ich auf diese Hotspots drauf eingehen, weil ansonsten skaliert es halt nicht mehr. Das ist wichtig. Ähm,
Dr. Michael Köpf
also das finde ich tatsächlich ähm also da habe ich mir auch schon viele Gedanken drüber gemacht über dieses ähm sozusagen Schichtenmodell, ja, in dem man sich dann ähm letztlich auch Codeänderungen angucken kann. Ähm, ich finde das auch interessant aus der sozusagen aus der Eingabeseite. Also, wir haben es jetzt ja gerade besprochen, ähm um vielleicht eine eine Änderung zu beurteilen, aber auf der anderen Seite gibt's ja auch ähm jetzt schon seit längerem eine große Diskussion darüber, wie ich jetzt optimal eigentlich, ich sag mal, prompte, ja, und das dann auch weitertreibe, z.B. zum was jetzt alle als als Spec Driven Development aktuell bezeichnen. Äh und da frage ich mich halt auch, ob es auch auf der Seite sozusagen bessere Wege geben könnte. Das hat man natürlich in der Vergangenheit schon häufiger probiert. Also dieses Model Driven Development und so weiter geht vielleicht so ein bisschen in die Richtung, ne? Dass ich dann vielleicht auch Änderungen auf dieser z.B. Klassendiagrammebene oder auf einer anderen sozusagen Architektursichtebene ähm durchführe und das dann praktisch verwende, um damit dann Code zu erzeugen. In der Vergangenheit hat das ja nicht so gut funktioniert. Ähm glaubst du, dass ich das durch KI ändert oder bist du da auch eher skeptisch?
Matthias Endler
Die Frage ist, wieso es in der Vergangenheit nicht so gut funktioniert hat. Ich glaube, das Problem damals war, das war tatsächlich auch zu meiner Unizeit und ich kenne diese modellgetriebenen Systeme auch. Ähm es hat so ein Stück weit das Vokabular gefehlt, auszudrücken, was man konkret im Code geändert haben möchte oder wie der Code auszusehen hat. Und das Ergebnis war eben, dass der Code eigentlich nur für Maschinen gedacht war und teilweise viel zu lang und viel zu groß und man hat halt dann den Wald von lauter Bäumen nicht mehr gesehen und hat dann eigentlich versucht ja mit einem Hammer ein Motor zu reparieren. Also es war ein viel zu grobes Tool dafür, was man eigentlich machen wollte und da müsste man eine Lösung finden, wenn man den Ansatz jetzt noch mal verfolgen möchte. Also, ich weiß es nicht genau, wie das dann konkret aussehen soll. Ähm, aber ja, ich gebe dir recht. Also, wir sind, was das Tooling angeht, so ein bisschen in den 90ern hängen geblieben, arbeiten wirklich immer noch mit Text und mit Diffs und so weiter und und diese Art der Kommunikation funktioniert halt nicht, wenn man das jetzt wirklich hochskalieren möchte auf diese Art und Weise. M das andere, was mir in Erinnerung geblieben ist aus der Zeit, war die Tools waren extrem langsam. Also natürlich waren die Computer auch von den Ressourcen her ein bisschen begrenzter, aber ähm es hat keinen Spaß gemacht mit diesen Tools wirklich interaktiv zu arbeiten. Also es kam jetzt nie so ein Workflow auf, wo ich sag, okay, ich bin jetzt in in diesem Flowstate und kann mich konzentrieren auf die Aufgabe, sondern ich hatte auch immer noch drumherum das ganze Tooling und es war sehr behäbig. Mhm. Und da müsste man vielleicht auch ansetzen und sagen, okay, wie sieht vielleicht leichteres Tooling aus? Also, wenn ich jetzt die Möglichkeit habe, z.B. fünf verschiedene Varianten von dem Projekt in paar Minuten zu erzeugen oder vielleicht sogar in Sekunden den Prototypen zu analysieren. Wie wird das dann aussehen? Also, wie bekomme ich das als User dann auch präsentiert und wie kann ich dann entsprechend einschreiten und auf welcher Ebene kann ich dann noch Eingriffe machen? Also, das ist halt die Frage, wie viel macht man dann selbst und wie viel macht man deklarativ, indem man es beschreibt?
Jan Schulte
Kommen wir vielleicht noch mal zurück. äh ein bisschen zu Rust, weil das ist ja quasi dein Hauptfokus auch. Ähm und Rust galt ja lange Zeit als sehr komplexe, Sprache, schwierig zu erlernen und Rust, er er fährt ja gerade jetzt ein bisschen im mit diesen ganzen AI halt wieder. Ich will nicht sagen Revival, weil es war ja nicht nicht in die klein, das war ja schon am ähm ähm am am Wachsen. Ähm aber noch mal so ein so ein speziellen Hype würde ich sagen, ne? Und ähm ich glaube, das was in letzter Zeit sehr ähm sehr stark durch die Twittersphäre ging oder so war der Rewrite von Bun von Zig nach Rust ähm was ja sehr viel Medienaufmerksamkeit erhalten hat. Ähm und ich habe da mal ein paar Zahlen raus gesucht. Also Jarred Sumner hat das irgendwie innerhalb von 11 Tagen quasi komplett nach Rust portiert. ähm über eine halbe Million Lines of Code ähm mit einer Peak von äh 700 Commits pro Stunde, also quasi zum Großteil komplett AI ähm äh portiert ähm und äh von API Kosten her ähm schätzt ungefähr 170.000$ hat das gekostet, was natürlich für für ein Projekt von so einer Größe eigentlich extrem gering ist, ne? Wenn man das jetzt irgendwie vor 5 Jahren gemacht hätte oder so, wären die Kosten wahrscheinlich viel viel höher gewesen. Ähm und ähm genau da wie siehst du das? Äh wann würde würdest du jetzt raten, dass ähm Firmen äh gerade so Performance oder sicherheitskritische Anwendung, wofür natürlich Rust extrem gut geeignet ist, ähm portieren sollen mit Hilfe von AI oder siehst du das Ganze eher noch ein bisschen kritisch?
Matthias Endler
Ja, also noch mal ganz kurz zurück zu der Frage Rust und Komplexität. Also ich glaube, es liegt gar nicht an Rust, dass es diesen Ruf hat komplex zu sein, sondern einfach daran, dass die Welt relativ komplex ist. Systeme sind komplex und die muss man natürlich irgendwie abbilden, sowohl mental aus als auch in Code und Rust hat halt die Eigenschaft, dass viele Fragen ganz am Anfang der Entwicklungsphase im Prototyping und in der Entwicklung dann beantwortet werden müssen, weil ansonsten das Programm gar nicht kompiliert, also man kommt gar nicht an dem Punkt, wo diese Probleme dann in der Realität auftreten, was aber häufig dazu führt, dass es vor allen Dingen für Anfänger sehr frustrierend sein kann, weil man sich erstmal damit auseinandersetzen muss, was die Probleme eigentlich sind. Ähm viele Sachen, wie z.B. das Lesen einer Datei klingen relativ simpel, bis man dann merkt, dass man vielleicht nicht alle Edge Cases ähm abgefangen hat. Also, wie groß ist die Datei, ähm welches Encoding hat die Datei? habe ich überhaupt Rechte darauf zugreifen, zuzugreifen und so weiter. Und diese ganzen Entscheidungen werden eben ähm in anderen Sprachen zur Laufzeit getroffen und in Rust zur Compilezeit. Und und da glaube ich ist auch dieser Ansatz, weshalb Rust so populär ist in der KI Welt, sage ich jetzt mal, weil man ausgeht davon, dass man die Vorteile vom Rust verbinden kann mit die den Vorteilen von Code Generierung und man ist dann quasi schnell unsicher. Ich weiß nicht, ob das so hundertprozentig stimmt. Also man man verlässt sich schon schon sehr sehr stark auf Rust, aber Rust löst keine Business Logik Probleme, die hat man nach wie vor. Auch mit Rust wird man in Situationen laufen, wo die Logik, wenn diese inkorrekt ist, das Programm auch in korrekte Ausgaben macht oder vielleicht sogar abstürzt. Und das geht auch in Rust relativ einfach indem dass man z.B. ein Slice Operator benutzt auf einen String und den Index verwendet, der in dem String nicht existiert, dann ist das auch schon Panic. Und deswegen glaube ich ist es ein bisschen gefährlich, wenn man eine große Codebase automatisiert, vollkommen automatisiert umschreiben lässt. Weil ich glaube konkret jetzt bei dem Fall Bun ist es so, dass es auch schon vorher Anzeichen gab, dass die Codebase nicht unbedingt idiomatisches Zig war und man dann halt vielleicht eine Lösung gefunden hat, um die diese Zig Probleme zu verbessern oder vielleicht auch zu mitigieren, indem dass man das ganze Projekt einfach migriert hat zu einer anderen Programmiersprache. Dann hat man letztendlich ähnliche Probleme nur in der anderen Programmiersprache. Also, ich habe mir die erste Version von dem Rewrite angesehen und das war mit Sicherheit nicht idiomatisch und Code an sich ist auch nicht billig. Das heißt, ja, man kann kann sehr viel Code generieren. Das heißt aber nicht, dass Maintenance plötzlich wegfällt. Das heißt nicht, dass Refactoring plötzlich wegfällt. Im Gegenteil, je mehr Code man generiert hat, desto höher werden die Kosten eben für Refactoring und für größere Umstellungen. sei denn, man verwendet dann wieder KI, um dieses Refactoring zu machen, aber man kommt halt dann relativ schnell an den Punkt, wo man auf dieses Tool dann nicht mehr verzichten kann und vielleicht selber auch keinen Überblick mehr hat. Also schlechter Code macht KI Vorteile zunichte und ich muss allerdings auch fairerweise sagen, dass sich der Code von Bun über die letzten Wochen extrem verbessert hat. Also, der sieht wesentlich besser aus, als der ganz am Anfang war. Und ich will jetzt auch gar nicht sagen, dass es für dieses Team jetzt speziell ein schlechter Schritt war, aber aber ich glaube, man muss ganz offen und ehrlich über die Probleme diskutieren, die man hat und auch realistisch sein. Also eine Sache, die z.B. erwähnt wurde, war ähm war es Performance oder war waren es Compile Zeiten, ähm wo man nicht zufrieden war? Also ich glaube nicht, dass man das ohne jetzt großartig an der Algorithmen viel zu verändern oder an der Architektur von der Software diese Probleme lösen kann. Also vielleicht hätte man mit mehr Arbeit das Ganze auch auf der Zig-Seite lösen können. Ja, mit oder ohne Agenten, das ist ja erstmal egal.
Jan Schulte
Ja, Michael, du wolltest?
Dr. Michael Köpf
Also für mich ähm also ich habe tatsächlich ähm Rust noch mal sehr sehr kurz ausprobiert. Ähm das muss irgendwann Gott äh 2020 oder 21 gewesen sein. Also mit Sicherheit 5 Jahre her. Ähm also ich ich habe bin kein Experte dafür. Ähm aber ich finde die Vorteile natürlich auch sehr spannend. Äh, ich frage mich aber auf der ähm auf der anderen Seite ähm was was mache ich denn jetzt heute wirklich, wenn ich neu in das ganze Feld ähm Coding reinkomme? Äh, wir müssen ja, glaube ich, oder muss ich glaube ich heutzutage sehr stark überlegen, was sind denn eigentlich die ähm die Tätigkeiten, die ich als Mensch noch mache, ja, oder die die wichtig sind, dass ich dass ich die als Mensch erlerne. Und äh es gibt sicherlich Dinge, die in Zukunft LLMs halt machen werden. Ja, also das glaube ich ähm da kann man nicht nicht dran vorbeireden. Ähm, deshalb es ist für mich dann die Frage, wie viel würdest du heute noch, wenn du es neu starten würdest, sozusagen investieren ähm z.B. in so ein detailliertes Verständnis einer Programmiersprache. Ja, und nehmen wir meist natürlich in deinem Beispiel Rust.
Matthias Endler
Das ist eine gute Frage. Also, ich habe zu einer Zeit programmieren gelernt. Ja, da gab's kein Internet. Ähm, ich habe wirklich noch Bücher verwendet und der der Editor, der halt auf äh Windows äh 95 drauf war, der hatte halt nur Basic und deswegen war das halt die Sprache der Wahl. Und ich wusste aber schon damals, dass mich einfach Systeme interessiert haben. Also ich denke nicht jeder will genau wissen, wie Systeme funktionieren, aber wenn man einfach diese Motivation hat, ist es, glaube ich, relativ schwer zu unterdrücken, dass man immer fragt, warum ist das so? Und man kommt dann zwangsläufig irgendwann äh an dem Punkt, wo man sich mit Programmiersprachen oder vielleicht mit Maschinen und Hardware und äh Architektur und so weiter auseinandersetzen muss. Die Frage ist eigentlich eher, was wäre passiert? GB's jetzt andere Tools, die vielleicht von vorher rein spannender wären oder wo man vielleicht relativ schnell Ergebnisse sieht? Ich glaube schon, dass ich die verwendet hätte und das beste Beispiel ist, ich habe lange Zeit auch einfach nur HTML Webseiten gebaut, einfach nur, weil das visuell war, man konnte schnell was sehen und man konnte interagieren und man hatte auch die Möglichkeit mal Fehler zu machen, ohne dass z.B. der Browser die Seite nicht anzeigen konnte. Also, da würde ich behaupten, ich habe auch Erfahrung gemacht mit diesen Tools, die einfach schneller zu Ergebnissen führen, aber m ich glaube heutzutage ist es schwieriger an einen Punkt zu kommen, wo man dann vielleicht zum ersten Mal wirklich in Kontakt tritt mit der Maschine und dann auch selber dann Code schreiben muss, weil es halt auch nicht weiter geht und weil man eben dieses Ziel hat, z.B. man will ein Computerspiel schreiben oder so m dass man dann sagt da okay, dann reichen mir z.B. HTML und CSS nicht mehr, dann brauche ich JavaScript oder so. Das wird sich wahrscheinlich schon ändern. Jetzt heutzutage kenne ich sehr sehr viele junge Leute, die einfach agentisch an die Sache rangehen und die auch wirklich beeindruckende Dinge bauen. Also ich kenne persönlich jemanden, der jetzt gerade Computerspiel schreibt und das ist sehr cinematisch und erinnert so ein bisschen an Stardew Valley, aber ähm diese Person hat jetzt einfach gar keinen Bezug zum Code an sich. Das ist wirklich nur der Output so wie früher eine eine Binaryre Datei. Also es ist halt eine Exe oder vielleicht wenn das jemand noch kennt so eine Flashdatei. Die ist halt letztendlich einfach nur die Beschreibung von dem Programm. Aber man arbeitet auf einer ganz anderen Ebene. Ich denke beides ist richtig am Ende. Es kommt eher drauf an, was man für eine Person ist. Vielleicht Leute, die einfach extrem logisch und analytisch denken, haben schon gewisse Vorteile, dann noch in diesem Feld dann tiefer einzusteigen und vielleicht auch dann in der Forschung oder in der Wirtschaft dann vielleicht auch die Modelle dann voranzutreiben. Interessantes Thema wäre ja auch Robotik, dass man sagt, okay, wie bringe ich das dann auch in die reale Welt? Und da muss man dann schon auch Verständnis haben, wie die ganzen Dinge funktionieren, inklusive der Hardware, aber für die allermeisten ja weiß ich nicht, ob das dann noch so relevant sein wird. Also, ich glaube, das ist so ähnlich wie der Übergang von Assembly nach C oder vielleicht von von C zu JavaScript, dass man dann halt einfach sagt, okay, gewisse Sachen musst du einfach nicht mehr wissen, um produktiv zu sein. Und die frühere Generation sagt, nee, das muss man unbedingt wissen, weil sonst ist man kein richtiger Programmierer. Ich glaube, das ist äh nicht wahr. Also, ich würde eigentlich jedem ähm raten, sich damit auseinanderzusetzen und einfach Dinge auszuprobieren. ist viel viel besser als wenn man sagt, okay, das ist eh nichts für mich dieses Feld, das interessiert mich nicht, weil weil ich glaube, erst dann haben wir ein großes Problem in der Zukunft, weil diese ganzen Systeme natürlich auch maintaint werden müssen und irgendwann muss halt jemand wissen, wie so eine Sandbox funktioniert oder eine Harness oder äh eine VM und da gibt's auf jeden Fall genug Arbeit auch noch in Zukunft, dass Leute sich intensiver vielleicht mit Programmierung auch beschäftigen, aber der Einstieg wird erleichtert und ich denke, das ist was Gutes.
Jan Schulte
Da drauf will ich noch mal ganz kurz eingehen. Also ähm wie du jetzt sagst, das ist natürlich viel einfacher jetzt in neue neue Programmiersprachen auch reinzukommen und ähm ja, ich komme auch aus der Zeit, wo wo ich Coding noch mit Büchern gelernt habe. Bei mir war es C++ und ähm also ich kenne die Zeit gut und es war natürlich früher so, dass um wirklich irgendwie produktiv in der Programmiersprache zu zu werden, hat es schon ein bisschen gedauert, ne? Weil es ja nicht nur das Verständnis der Programmiersprache, sondern auch einfach das Verständnis, okay, wie funktioniert das ganze Tooling drumherum? Äh was sind so typische Libraries, die man verwendet etc. pp, ne? Und ähm das ist natürlich jetzt heutzutage mit AI viel einfacher ähm quasi das ähm ja neue Projekte in anderen Programmiersprachen zu machen, ne? Weil Rust ist nicht äh geeignet für jede für jedes Projekt, ne? Genauso wenig Typescript oder Go oder was auch immer. Ähm und da geht, also früher war es natürlich dann schon oft so, dass man vielleicht die Projekte, ne, in so einer Firma, wenn du jetzt großes Team mit Rust hast, dass einfach Experten in Rust sind oder in Typescript Scala, was auch immer, dass dann halt natürlich auch neue Microservices oder so unter Umständen halt in dieser Sprache gemacht äh ähm wurden, obwohl es vielleicht nicht unbedingt die die geeignet Sprache war. Ähm, siehst du das problematisch, dass wir jetzt quasi mehr ähm also die zum einen halt dieses dieses Teamwissen vielleicht dann so ein bisschen verlieren, aber auf der anderen Seite äh mit ähm Polyglotter werden, ne? Also, dass halt Firmen viel offener sind, auch neue Sprachen auszuprobieren oder halt den neuen Microservice halt in Rust zu schreiben, statt wie früher in Scala oder so.
Matthias Endler
Ich probiere natürlich auch super viel mit anderen Sprachen aus und das spart mir natürlich extrem viel Zeit jetzt aktuell vielleicht auch mal das Boilerplate oder so mal erstellen zu lassen oder vielleicht einfach mal relativ schnell mal den Prototypten Sam mit dem man auch rumspielen kann. Also bestes Beispiel ist, ich hatte noch nie eine iOS App geschrieben. Habe mir jetzt eine geschrieben für mich persönlich, die halt genau das macht, was ich brauche und nicht mehr, aber das war halt in Swift und ich persönlich kann kein Swift und ich fand es aber trotzdem mal interessant auch dieses Tooling mal kennenzulernen und zu sagen, ah okay, so würde man das vielleicht in Swift bauen. Was ich natürlich nicht beurteilen kann, ist, ob das idiomatisch ist, aber für persönliches Projekt ist das wahrscheinlich erstmal nicht so wichtig. Zu der Sache, wie würde ich das in Teams machen? Ich glaube, da würde ich noch generell erstmal ein bisschen ähm anders denken. Ähm ich ich glaube, die Programmiersprache an sich ist nicht unbedingt der Hauptgrund, weshalb Teams sich standardisieren auf eine Sprache, obwohl es irgendwie tautologisch klingt, aber in Wirklichkeit ist es eher das gemeinsame Verständnis von dem kompletten Ökosystem. Also, wenn ich jetzt z.B. Go verwende, dann habe ich klar den Compiler, aber ich habe natürlich auch meine ganze CICD Pipeline, die ich mal gebaut habe. Ich habe meine Art und Weise, wie ich deploy, also mache ich z.B. Docker Container oder Go Binaries. Ähm, ich habe das Logging, ich habe ähm Monitoring, Metrics und so weiter und dann habe ich halt noch meine ganzen Patterns und die Libraries, die ich möglicherweise im besten Fall auch mal gereviewt habe und geschaut habe, ob die noch aktuell sind. Und da ist halt auch der Vorteil, dass man sich Kosten spart, indem dass man sagt, wenn man z.B. eine Library hat, die nicht mehr maintained wird, dann löst man das Problem einmal für das ganze Team und dann kann man eben das alle Projekte updaten auf die neue Library, weil die funktioniert dann überall wieder gleich. Oder man muss z.B. auch mal einen Teil selber schreiben und will den vielleicht nicht in fünf verschiedenen Sprachen schreiben, sondern nur in einer. Also, ich denke, es gibt schon noch andere Vorteile, weshalb man sich auf eine Programmiersprache fokussiert. Aber ich sehe auf jeden Fall auch die andere Seite, dass man früher oft gesagt hat, das ist jetzt zu aufwendig und ja, wir wir können das jetzt nicht neben unserer normalen Arbeitszeit machen und das war halt immer ein Blocker, weil man muss um z.B. eine neue Programmiersprache einzuführen in dem Unternehmen auch einfach entsprechend in Vorleistung gehen und dann auch zeigen, dass diese Sprache eben kann, was was behauptet wird. Ja, speziell jetzt für Rust ist natürlich super, wenn man sagen kann, okay, ich kann mir jetzt schnell mal ein 50.000 Zeilen Prototypen bauen, ich kann den mal für 1% vom Traffic verwenden und dann sehe ich, ah ja, okay, ich spar mir 90% der Server und es ist wirklich so, dass ich mir 50% Memory spar und äh ich habe keine Kompilierprobleme oder sowas. Ähm, also, dass man eben diese diese Vorurteile so ein Stück weit versucht auszuräumen, indem dass man einfach mal einen Prototypen schreibt und nicht immer im Kämmerchen überlegt, weil man denn mal Zeit hat für so ein Projekt. Also, ich glaube, das ist super hilfreich und ich würde es auch jedem Unternehmen empfehlen, einfach verschiedene Sprachen auszuprobieren, nicht nur Rust, aber besonders Rust natürlich in erster Linie Rust, aber dass man sagt, ja, okay, wie sieht denn jetzt das Tooling aus auch nach ein paar Jahren z.B. Das hat sich auch in C++ getan. Wie kann ich das modernisieren? Das hört ja bei der Sprache nicht auf. Ja, also ähm da seh ich schon Vorteile. Ja. ähm
Jan Schulte
vielleicht noch mal da drauf dann auch eingegangen. Das hast du jetzt ja schon gesagt, dass dass du es so ein bisschen so siehst, ne, dass äh wie damals irgendwie von Assembler dann oder von C nach äh nach äh also kompiliert hat, dass man dann quasi einfach nur eine Binary hat und keiner identifiziert sich jetzt nicht mit der Binary und ähm du hast einen Kollegen, der ein Spiel baut und der interessiert sich nicht für den Rust Code, der da rauskommt. Ähm wie wie siehst du das in ähm in 5 Jahren? Ähm glaubst du, dass wir in 5 Jahren überhaupt noch über Programmiersprachen äh diskutieren, ob das überhaupt noch relevant ist oder glaubst du, wir sind dann einfach schon komplett auf dieser vielleicht neuen Ebene, wo wir dann eher auf äh keine Ahnung Semantik und Architektur ähm nur noch da drüber nachdenken und ähm keine Ahnung, der eine Microservice dann vielleicht automatisiert in Rust generiert wird und die Web App automatisiert in Typescript generiert wird und so weiter.
Matthias Endler
5 Jahre klingen lang, aber das das Ökosystem hat sich jetzt nicht so dramatisch verändert den letzten 5 Jahren auch mit KI nicht unbedingt. Also man verwendet ja immer noch dieselben Sprachen, aber es kommen natürlich jetzt immer neue Sprachen nach, die vielleicht auch gewisse Sachen mal ausprobieren und vielleicht mal testen. Kann ich sowas wie JavaScript bauen ohne Garbage Collector oder was wäre, wenn ich C 2026 neu schreiben würde? Wie wird das aussehen mit modernen Ideen? Und zusätzlich glaube ich wird's interessant mal zu sehen, was mit den Programmierparadigmen passiert. Also früher gab es ja nicht so viele. Es gab irgendwie imperativ, funktional, objektorientiert. Aber wie wird denn z.B. neues Paradigma aussehen, wenn man wenn man jetzt einfach die Möglichkeit hätte, das einfach mal durchzuspielen für verschiedene Anwendungsfälle. Also, ich denke, da ist noch sehr, sehr viel Luft nach oben, dass man experimentiert mit verschiedenen Ideen innerhalb von Programmiersprachen, aber auch mit neuen Programmiersprachen. Also was ist z.B., Wenn nebenläufige Ausführung, also asynchron programmieren irgendwie so First Class ware, wie wird das wirklich aussehen oder oder wie funktioniert eine Programmiersprache, die ähnlich ist wie CUDA für Grafikkarten, aber in Wirklichkeit für CPUs? Also wie kann ich das, was wir ähm Programmieren nennen oder eigentlich äh Informationstechnik, wie wie kann ich das vielleicht noch darstellen, noch modellieren? Also, da gab's über die Jahrzehnte ja immer mal wieder irgendwelche Vorstöße und Ausreißer, also Forth z.B. ähm eine der Programmiersprache, die Stack basiert ist, die einfach ganz anders funktioniert wie eine traditionelle Programmiersprache und die hat auch Anwendungsfälle, ja, wo man sagt, ah, okay, angenommen, ich habe jetzt ein sehr sehr spezielles Set an Requirements und ich will jetzt in genau diesem kleinen lokalen Bereich optimieren, was könnte ich tun, um das perfekte Tool dafür zu schreiben? Wie wird dieses perfekte Tool aussehen? Ich glaube, das wird super spannend, weil es halt heutzutage günstig ist, damit zu experimentieren und eine neue Programmiersprache auszuprobieren. Das ist übrigens auch noch mal das andere, ähm, dass man sagt, okay, jeder inklusive Leute, die schon programmieren können, kann jetzt ähm in die Tiefe gehen auch. Also ähm man man muss nicht unbedingt Highlevel bleiben, sondern man kann auch z.B. die Zeit nutzen, um Sachen zu bauen, für die man halt vorher keine Zeit hatte oder keine Expertise. Also, was ist, wenn ich ein Kernel Treiber schreiben will oder ich will ein Emulator bauen für eine Konsole z.B., Spiel, aber ich habe mich halt vorher nicht dran getraut, weil das eben 5 Jahre Projekt ist. Ja, dann kann ich das jetzt machen und kann halt interaktiv lernen und genauso gut kann man das eben auch mit Programmiersprachen dann spielen und dann sagen, ah okay, was ist, wenn ich meine eigene Programmiersprache schreiben will? Und wenn mehr Leute Zugang dazu haben, dann führt das meiner Meinung nach auch zu besseren Ergebnissen, weil halt einfach mehr Konkurrenz und mehr Diversifikation einfach dazu führt, dass man ja ähm vielleicht auch mal einen Gewinner dabei hat, eine Programmiersprache, die dann langfristig auch maintained wird.
Dr. Michael Köpf
Ja, was ich dabei natürlich super spannend finde, ist die Frage, wie weit kann jetzt ähm KI, also wenn man sich anschaut, wie wie LLMs ähm letztlich ja trainiert werden und wie sie funktionieren, ähm sozusagen neue äh also mit neuen Paradigmen umgehen oder vielleicht sogar auch also schon einfacher mit einer neuen Programmiersprache. Ja, also wenn ich mir vorstelle, klar, ich kann jetzt auf eine für mich persönlich neue Programmiersprache, die aber schon länger am Umlauf ist, natürlich relativ leicht umsteigen oder damit Experimente machen. Ähm, die Frage ist, wenn es tatsächlich eine ganz neue Sprache rauskommt, ähm wo also in inwiefern kann ein ähm ein LLM System damit dann äh gut umgehen? Ja, wie wie lernt das überhaupt? Na, ich weiß jetzt gar nicht, ob es da schon Beispiele für gibt. Ähm, tatsächlich, weil es gibt's ja LLMs tatsächlich schon ein paar Jahre. Ja, aber ähm ich weiß nicht, was was werden denn deine Gedanken dazu? Ich stell mir das Problem erstmal grundsätzlich äh schwierig vor.
Matthias Endler
Ja, weil natürlich der ganze Trainingskorpus ausgelegt ist auf andere Programmiersprachen, die ehrlich gesagt relativ ähnlich funktionieren. Also ob jetzt Java oder Typescript, am Ende sieht der Code, die Logik trotzdem relativ ähnlich aus. Man hat halt Variablen, man hat Zuweisungen, man hat if Conditions, man hat Schleifen, das hat man ja in sehr sehr vielen Sprachen und dann hat man meistens drüber noch so ein Überbau und bei Rust Code sieht man das auch. Also, dass das Code, der eben von LLMs generiert wird, eher imperativ ist und sehr, sehr lang und dass man sagt, ah, okay, da kommt halt dieser OOP Teil auch ein bisschen durch, wie eben die Modelle dann Code strukturieren im größeren und das ist extrem spannend zu sehen, weil jemand, der z.B. mehr Ahnung von Rust hat, wird vielleicht eher dann Richtung Traits gehen und wird das eben äh component basiert machen und wird eben sagen, okay, statt Vererbung würde ich eher Composition verwenden und wie wird das Programm dann idiomatisch aussehen? Das das finde ich super spannend, das zu sehen oder oder auch eine lange Methode aufzubrechen und zu sagen, okay, was sind eigentlich die elementaren Bauteile, weil es wird häufig einfach Code hinzugefügt, aber selten wird der Code dann eben refactor, weil es dafür einfach keine Optimierungsfunktion gibt. Also die Aufgabe ist, macht diese Änderung und dann versucht man natürlich mit möglichst wenig Veränderungen dann den größten Reward zu bekommen. Aber wenn man wenn man halt nie aktiv sagt, ähm die der Reward ist refactoring oder versucht das so idiomatisch wie möglich zu bauen, dann wird das halt nicht automatisch passieren und dann kommt man halt irgendwann an der Codebase bei einer Codebase raus, die man vielleicht selber ähm nicht versteht oder ganz anders aufbauen würde. Ähm wie ist das jetzt konkret, wenn es wenn jetzt neue Sprache kommen, also kann die KI da entsprechend ähm aufschließen? kann die KI das direkt verstehen und umsetzen? H, ich glaube nicht, dass es da einen großen Unterschied gibt zwischen Mensch und Maschine. Ähm, es wirkt vielleicht so, weil die Maschine natürlich schneller ist, aber man braucht trotzdem dieses Verständnis. Und wo das herkommt, ist halt die Frage. Also, man kann vielleicht über so ein RAG nachdenken, dass man eben äh die Spezifikation von der Sprache erstmal ähm ins LLM lädt, wenn der Kontext entsprechend groß ist. Und und das könnte schon mit unter funktionieren. Da gibt's ja auch Tools wie Context7, die halt dann die Möglichkeit haben, dass man z.B. für eine Library ein Spec reinlädt oder es ist sogar noch ein bisschen schlauer, das ist ja eher dann vektorbasiert, dass man dann auch entsprechendes suchen starten kann und ich glaube schon, dass man da über solche Möglichkeiten dann auch z.B. lokal dann auch ein Verständnis für die neuen Programmiersprachen aufbaut. Aber ich glaube auch, dass das in Zukunft ein großer Teil von der Sprach vom Sprachdesign sein wird, dass man dieses Spec eben liefert, dass es gar nicht anders geht, als würde man jetzt ohne Spec anfangen wäre das eigentlich ziemlich ähm von Nachteil und dass man dann vielleicht sagt, ja, okay, ich will, dass meine Sprache angewendet wird, dann muss ich eben dieses Tooling auch bereitstellen. Also vielleicht ein MCP Server oder vielleicht eine Vector Search, damit damit neue Modelle das auch lernen können, äh wie die Programmiersprache funktioniert. Ja, ich ich glaube auch, das wäre interessant für Rust, dass man sowas baut und vielleicht sagt, okay, wie wird so ein Refactoring Skill aussehen oder oder vielleicht eben ein Tooling, so ein MCP, wo man sagt, da okay, ich will auf andere Ebene mit dem Code interagieren, m damit ich den halt verbessern kann und vielleicht auch in erster Linie erstmal generieren kann.
Jan Schulte
Ja, ähm wir sind ein bisschen über der Zeit. Ähm, Matthias, vielleicht einen letzten äh letzten Tipps oder so, die du unseren Zuschauern geben müsst äh willst ähm bezüglich KI Nutzung oder äh Entwicklung mit Rust.
Matthias Endler
Also, ich glaube, das erste, was ich tun will, ist den Leuten die Angst zu nehmen, dass jetzt einfach alle Jobs direkt wegfallen oder so. Ich glaube da nicht dran. Also ähm ich denke eigentlich im Gegenteil, man sollte diversifizieren und vielleicht auch einfach schauen, wo man die Vorteile für sich nutzen kann im Alltag, wo man wo man vielleicht Anknüpfungspunkte sieht. Ähm, aber es hilft jetzt nichts, wenn man sich davor verschließt oder wenn man jetzt komplett blauäugig dann äh an das Thema rangeht. Aber auf der anderen Seite will ich auch sagen, dass es immer noch sehr sehr hilfreich ist, einfach ein Verständnis aufzubauen von Systemen, von Programmiersprachen, nur um sich mental zu trainieren. Selbst wenn in Zukunft irgendwann der das der Fall sein sollte, dass man vielleicht diesen Muskel nicht mehr aktiv in der Arbeit braucht, was ich nicht glaube selbst, dann wäre es sinnvoll, einfach sich da mental fit zu halten und sein Wissen einfach immer auf dem aktuellsten Stand zu halten. Ähnlich wie bei einem äh Workout z.B. Ähm ich denke, man soll sich mit den Methoden auseinander setzen, also DDD haben wir ja schon besprochen, vielleicht auch Testdriven Design. Ähm wie baue ich generell äh Code auf für meine Sprache jetzt in Rust, wie funktioniert z.B. Composition statt äh Inheritance und dann halt auch das ganze Tooling verwenden, das sonst schon existiert, also Formatter, Linter und so weiter, die gab's ja vorher, die kann man jetzt auch wieder ähm einsetzen und dass man für sich seinen Weg findet und vielleicht auch sagt, ja, okay, da ist sind zwei, drei Dinge dabei, die ich selbst für mich noch lernen kann. Selbst wenn ich den Code vielleicht selber schreiben will, kann ich mir trotzdem Ideen und Inspirationen holen. Also, da gibt's einfach verschiedene Arten und Weisen, wie man damit umgeht. Ähm, aber so generell würde ich sagen, es ist gibt immer noch Sinn, das Wissen zu haben und auch einfach mit den Leuten zu reden und einfach normale Fragen zu stellen und zu schauen, ähm, wie funktioniert das Team, wo ist das Verständnis und wo müssen wir vielleicht äh rangehen und ähm das Verständnis noch verbessern im Team?
Jan Schulte
Super, vielen Dank, Matthias. Schaut auch in Matthias Podcast Rust in Production rein. Den Link packen wir in die Comments bzw. Description. Vielen Dank, Matthias.
Matthias Endler
Sehr, sehr gerne. Danke schön. M.