Was ich da auch sehe: Support fĂŒr das Build Server Protocol. Kannte ich bisher noch nicht. Reiht sich dann ein zum Language Server Protocol und dem Debug Adapter Protocol.
Posts mit Tag "language-design"
Google hat eine IR fĂŒr JavaScript gebaut: JSIR.
Ziel ist es, JS -> JSIR -> JS zu ermöglichen, sodass mehrere Toolchains sich die IR teilen können, Àhnlich wie es ESTree macht.
Vielleicht wĂ€re das was fĂŒr React Compiler. Die haben ihre eigene IR mit SSA gebaut, die von und nach ESTree compiled. Die JSIR wird dafĂŒr sicher nicht 100% ausreichen, aber die Integration in OXC könnte damit weniger Overhead haben.
Wo wir gerade bei PHP waren: Partial Application kommt auch.
Der Post liest sich viel zu positiv. âSo einfachâ kann es doch gar nicht sein, das wĂŒrde ich von C++ nicht erwarten. Da gibt es in der Praxis dann bestimmt noch ein paar hĂ€ssliche Sachen. Das âultra fast run scriptâ hat auch schon viel zu viele Einstellungen, die es tut.
Wie Zig Structs layoutet/padded: Memory Layout in Zig with Formulas.
Matt Godbolt macht einen Adentskalender ĂŒber Compileroptimierungen.
Hier ist die ganze Playlist ĂŒber alle Tage.
Ein REPL, um mit einer (Programmier-)Sprache Musik zu machen: Strudel.
V8 verwendet ja Pointer Tagging, um optimiert mit Zahlen zu arbeiten. Wer sowas selbst mal einsetzen will: Pointer Tagging in C++: The Art of Packing Bits Into a Pointer
YAML-Bashing hatte ich ja schon öfters hier. Eine gute Ăbersicht mit den Quirks: The yaml document from hell
WebAssembly Troubles part 1: WebAssembly Is Not a Stack Machine. Der ganze Blog enthÀlt noch mehr Posts in die Richtung.
Noch ein weiterer Post ĂŒber Strings in Programmiersprachen: The best â but not good â way to limit string length.
PEP 750 â Template Strings (t-strings) have been accepted. Damit hat Python jetzt auch sowas wie tagged template functions aus JS.
Ein Proposal fĂŒr C (N3317): Essential Effects for C
Diese Woche habe ich das Konzept von âGerman Stringsâ kennengelernt. Das sind immutable Strings, die mit einer erweiterten Variante der Short-String-Optimization gehalten werden. Sie enthalten noch in den 16 Bytes den PrĂ€fix vom String. Damit kann man viele String-Operationen machen, ohne den Pointer auf die Daten zu dereferenzieren. Und ist besser fĂŒr LokalitĂ€t bzw. Caching.
Der Name kommt wohl daher, dass in einem Paper von einem deutschen Stand und einer der ersten Implementoren zu faul war, den tatsÀchlichen Autor zu nennen.
Hier hat sie jemand in Rust implementiert, um einen Punkt zu beweisen. Dort wird auch der Autor vom Paper genannt: Umbra.
Beim Parsen von OperatorprĂ€zedenzen gibtâs ja verschiedene AnsĂ€tze. Der erste und âeinfacheâ Ansatz ist, die PrĂ€zedenzen in der Grammatik abzubilden. Die Implementierung mit einem rekursiven Abstieg ist dann trivial. Problematisch ist allerdings, dass der Syntaxbaum dann fĂŒr einfache Sachen ziemlich tief wird. FĂŒr z. B. ein einfaches a = 5 hĂ€tte man auf der rechten Seite dann einen kompletten Unterbaum mit Nodes fĂŒr jeden möglichen Operator, die dann aber quasi leer sind. Das ist sehr ineffizient.
Der nĂ€chste Schritt wĂ€re ein Parser mit Dokus auf OperatorprĂ€zedenz. Dort weist man jedem Operator eine PrĂ€zedenz in Form einer Zahl zu und löst es spĂ€ter ein einen vergleichsweise flachen Baum auf. Den OperatorprĂ€zedenzparser kann man in den normalen rekursiven Abstieg integrieren und dann fĂŒr binĂ€re AUsdrĂŒcke verwenden. TypeScript macht das z. B. auch so.
Hier ist ein anderer Ansatz, PrÀzedenzen zu parsen: Better operator precedence
Andrew Kelley bei CppCast ĂŒber Zig. Hier ist er auch noch bei einem anderen Podcast.
Die Web-Version von Crafting Interpreters.
Ich hab ja mal einen Prototypen eines SQL-Parsers auf Typebene entwickelt, um rohes SQL statisch zu typisieren. Hier eine EinfĂŒhrung, wie man auf Typebene in TypeScript programmieren kann.
Hello again! Iâm picking up my series on Automata, with this post that goes into what I had always meant to get to: parsers. Weâll check out the old-school linear time parsing algorithms, which only need to go over the input once, without backtracking or caching. Weâll check out LL and LR, parse tables, recursive descent and recursive ascent. Welcome to the world of deterministic parsingâŠ
atopile ist eine Sprache, mit der man Schaltkreise beschreiben kann. Komponenten kann man in Module aufteilen, erweitern etc. Die haben sogar CI-Support und einen Package-Manager. Bei Bauteilen kann man auch nur die benötigten Specs angeben und es werden passende Bauteile aus dem Katalog ausgesucht.
Hier ist eine Demo. Getting Started[hinweis] ist hier.
Das ist wirklich cool.
Apple sucht Compiler-Leute, die den Interop von Swift und C++ verbessern.
Swift ist IMHO eine wirklich unterschĂ€tzte Sprache. Die haben keine Angst vor breaking Changes und trotzdem schaffen sie es, kein Python 3 zu erzeugen. Der Code ist ĂŒblicherweise sehr lesbar und seit einiger Zeit haben sie sogar ein Ownership-Modell, das zwar etwas verboser ist, aber IMHO deutlich verstĂ€ndlicher als das von Rust ist. Vielleicht wĂ€ren sie populĂ€rer geworden, wenn Linux- und Windows-Support nicht so lange gedauert hĂ€tte, wer weiĂ ÂŻ\_(ă)_/ÂŻ
Hier ein guter Artikel ĂŒber Tagged Pointers: Storing data in pointers
Interessante Sprache von MS research: Koka.
Die Sprache handhabt Seiteneffekte mit einer Art Type-State.
Six programming paradigms that will change how you think about coding:
- Concurrent by default
- Dependent types
- Concatenative languages
- Declarative programming
- Symbolic programming
- Knowledge-based programming
A Primer on Type Systems (2018)
Artikel-Tipp: Substructural type system
Lesetipp: Why Checked Exceptions Failed Dazu gibt es noch einen Artikel mit Anders Hejlsberg (C#-Erfinder, wo es keine checked exceptions gibt): The Trouble with Checked Exceptions
Eli Bendersky ĂŒber Type Inference
Ein toller Post darĂŒber, dass das Error-Model einer der wichtigsten Teile in einer Programmiersprache ist: The Error Model (2016)
Geht auch ein bisschen auf Midori (ein experimentelles OS von MS Research) ein, das mit einer Erweiterung von C# entwickelt wurde.
Kaum ist das using (und async using) in JS standardisiert, kommt TypeScript mit support dafĂŒr.
Die Nightly-Version von TS im Playground kann es scheinbar noch nicht. Bin gespannt, zu sehen, wie das vim Compiler in Àltere JS-Versionen gelowert wird.
Kleiner Hack: Coroutines in C
Neulich hab ich was ĂŒber ein neues Feature von Java 21 geschrieben.
Hier gibt es eine Liste an den neuen, interessanten Sachen in Java 21: The compact overview of JDK 21âs âfrozenâ feature list. Was mir dort in die Augen fĂ€llt:
- Valhalla is officially trying to bite on the topic of Nullability in Java
Valhalla ist der Projektname dafĂŒr, user-defined Value-Types in die JVM zu bringen, Ă€hnlich zu denen in C# (Structs). Das zieht einen langen Rattenschwanz hinter sich her, darunter auch die Generics, die in Java mit Type-Erasure umgesetzt werden (in C# wird zur Laufzeit ein konkret anderer Typ instanziiert). Teil dieses Rattenschwanzes ist jetzt wohl auch Nullability.
Das wird jetzt nochmal viel interessanter, denn Nullability ist in Kotlin nochmal ganz anders gelöst. Ob wir am Ende einen super komplizierten Interop zwischen den Sprachen haben (was einer der Vorteile von Kotlin war) oder werden sie sich soweit voneinander entwickeln, dass sie inkompatibel werden?
Java bekommt das Ăquivalent zu Tagged Template Strings: String Template Expressions
Die Muttersprache der JVM entwickelt sich in eine andere Richtung als Kotlin. Kotlin hat dann bald viele Dinge redundant zu der nativen Java-Version.
Falls Ihr einmal einen RFC fĂŒr PHP schreiben wollt: The Mysterious PHP RFC Process and How You Can Change the Web (2013)
Die Leute bei Rust wollen das Coloring-Problem lösen. Den Artikel dazu hatte ich hier auch schon.
Der Versuch: Sagen, dass eine Funktion agnostisch bzw. âgenerisch bezĂŒglich ihrer AsynchronizitĂ€tâ ist. Da hört es aber nicht auf, sie wollen das auch ĂŒber const generisch machen. Der Plan ist sogar, das in Zukunft auch fĂŒr andere Keywords zu machen.
Das hier ist der erste Vorschlag: Keyword Generics Progress Report: February 2023
Money quote:
trait ?const ?async Read {
?const ?async fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
?const ?async fn read_to_string(&mut self, buf: &mut String) -> Result<usize> { .. }
}
/// Read from a reader into a string.
?const ?async fn read_to_string(reader: &mut impl ?const ?async Read) -> io::Result<String> {
let mut string = String::new();
reader.read_to_string(&mut string).await?;
Ok(string)
}
Das ist ein Read-Trait, bei dem die read-Funktion sowohl async als auch const sein kann. Primeagen (ein Rust-Enthusiast) ist nicht so begeistert. Wirt auf mich jetzt auch erstmal ziemlich verbose und bei einer Sprache, die bewusst keine Keywords mit mehr als 5 Buchstaben nimmt, fehl am Platz. Das haben sie aber offenbar auch selbst erkannt.
Zig möchte Funktionen auf diese Art farbenblind (manchmal auch farblos genannt) machen: What is Zigâs âColorblindâ Async/Await?
Hoffen wir mal, dass Rust nicht den Haskell-Tod der 1000 Abstraktionen stirbt.
Ein interessanter Artikel ĂŒber eine Anpassung bei einigen Concurrency-Modellen: Notes on structured concurrency, or: Go statement considered harmful
Erinnert ein bisschen an das Konzept von Erlang. Bei Java gibtâs gerade ein Proposal dazu: JEP 428. Ist auch bereits bekannt aus Kotlin.
Das Norway-Problem bei YAML war ja schon einmal hier. Hier ist eine gute Zusammenfassung vieler Probleme bei YAML: The yaml document from hell
Es gibt eine Studie aus 2010, die die Lesbarkeit von camelCase und snake_case untersucht. Sie kommt zu dem Schluss, dass snake_case um ca. 20% einfacher zu lesen ist. (Danke, Hans)
Wo wir gerade bei .NET 7 waren:
Die neue Preview (Preview 5) hat jetzt Support fĂŒr âGeneric Mathâ.
Das wird ermöglicht durch:
- Statische, abstrakte Interface-Member
- Dadurch OperatorĂŒberladung, die in Interfaces spezifiziert ist
Interfaces konnten bis C# 11 keine statischen Member von einem Typen verlangen. So war es z. B. nicht möglich, zu verlangen, dass eine Klasse den +-Operator implementiert. Auch nicht mit einem Type-Constraint.
Auch das bekannte Muster Parse und TryParse war mehr Konvention als irgendwie erzwingbar, weil beide Methoden statisch sind. Aus dem Grund war eine Lösung, Klassen zu erstellen, von denen es nur eine Instanz gibt. Anders konnte man keinen Type-Constraint erfĂŒllen, der durch Interfaces kam. DarĂŒber habe ich schonmal berichtet.
Jetzt ist das ganze ist jetzt schon deutlich konkreter geworden. Die neuen Interfaces dazu sehen sehr cool aus. Man kann damit jetzt den GroĂteil der Rechenoperationen abstrahieren.
Den Nutzen kann man gut sehen, weil sie in der LINQ die Min/Max-Funktionen damit ersetzen konnten. Es fÀllt echt viel doppelter Code weg.
Es liegt jetzt natĂŒrlich nah, diese Interfaces auch bei den Vector-Typen aus System.Numerics zu implementieren. Laut den Kommentaren in dem Artikel dazu wird das nicht mehr in .NET 7 passieren.
Auch neu:
.NET hat jetzt eine API, um TARs zu entpacken. Wenn man das mit dem bereits existierenden GZipStream kombiniert, kann man also ganz leicht ohne externe Libraries jetzt eine tar.gz entpacken. Deflate und Brotli gibt es dort ĂŒbrigens auch.
System.Text.Json kann jetzt anhand von einem Diskriminator-Feld zwischen in verschiedene Basisklassen deserialisieren:
[JsonDerivedType(typeof(Base), typeDiscriminator: "base")]
[JsonDerivedType(typeof(Derived), typeDiscriminator: "derived")]
public class Base
{
public int X { get; set; }
}
public class Derived : Base
{
public int Y { get; set; }
}
// ...
Base value = JsonSerializer.Deserialize<Base>(@"{ ""$type"" : ""derived"", ""X"" : 0, ""Y"" : 0 }");
// value is a Derived instance
Was in dem Blogpost nicht steht, aber in der Issue zu der Ănderung: Man kann die Property, auf die geschaut wird, wie folgt definieren:
[JsonPolymorphic(CustomTypeDiscriminatorPropertyName = "$case")]
(standardmĂ€Ăig ist es "$type")
System.IO.Stream hat jetzt ReadExactly und ReadAtLeast.
Das ist cool, weil das normale Read möglicherweise weniger Daten zurĂŒckgibt. Dann muss man eigene Logik bauen, um den Rest auch noch zu lesen. Das ist manchmal echt nervig gewesen.
Um das etwas zu entkoppeln, gibt es ĂŒbrigens noch was anderes: System.IO.Pipelines.
Wenn Ihr eine Library baut, gibtâs noch eine interessante Neuerung:
Das StringSyntaxAttribute. Das kann man an Member und Parameter kleben, um anzugeben, was der entsprechende String so fĂŒr Daten enthĂ€lt. So kann man z. B. sagen, dass soein String ein Regex-Pattern oder JSON enthĂ€lt. Die IDE kann dann entsprechend highlighten und generell ne bessere Editing-Experience geben.
VS gibtâs jetzt auch fĂŒr ARM64.
Neues aus den Standards:
Die schon in Stage 3 befindlichen Funktionen groupBy und groupyByToMap wurden noch umbenannt: Sie heiĂen jetzt group und groupToMap. Man hat eine JS-Lib gefunden, die den Array-Prototypen monkeypatched hat.
String.dedent, um EinrĂŒckungen von Template-Strings zu fixen.
Damit habe ich auch schon Probleme gehabt. Allerdings bin ich mir nicht sicher, ob man soeine Funktion mit guter DX umsetzen kann. In meinen Augen haben die immer Magie gemacht (sowas gibt es auch in Java und mittlerweile auch C#). Kennen tue ich das aus Xtend. Teilweise verÀndert sich das Verhalten, wenn man den String in einer eigenen Zeile anfÀngt oder es mit Tabs mischt. Vielleicht ist es aber auch ganz einfach.
Eine Erweiterung zu JSON.parse, mit der man feststellen kann, aus was fĂŒr einem String-Wert ein geparster Wert kommt. Und gleichzeitig das Verhalten von JSON.stringify zu verĂ€ndern.
Colle Idee.
Damit kann man basteln, dass man Timestamps nach JSON.parse schon parst. Damit spart man sich einen zweiten Verarbeitungsschritt. Oder man kann das Serialisieren von Timestamps in einen Unix-Timestamp umbiegen, wenn eine API das braucht.
Ein schöner Talk von Matt Godbolt: What Has My Compiler Done for Me Lately? Unbolting the Compilerâs Lid.
FĂŒr die, die ihn nicht kennen: Das ist der, der den Compiler Explorer gebaut hat: https://gcc.godbolt.org
Damit kann man sich anschauen, was fĂŒr Assembler-Code verschiedene Compiler aus Code erzeugen. Mittlerweile auch fĂŒr andere Sprachen als C und C++.
Der Talk ist sehr schön und zeigt, was fĂŒr Optimierungen der Compiler mittlerweile alle fĂ€hrt. Ein Beispiel ist die Integer-Mulitplikation mit 2, also z. B. x * 2. Spoiler: Es ist nicht x << 1. Aber auch ein paar gröĂere Beispiele sind durchaus beeindruckend.
Takeaway sollte sein: Optimiert nicht selbst, lasst das den Compiler machen. Ich wĂŒrde noch ergĂ€nzen: WĂ€hlt geeignete Datenstrukturen.
Chris Lattner on garbage collection vs. Automatic Reference Counting.
Chris Lattner ist der Designer von Swift und ursprĂŒnglicher Hauptauthor von LLVM.
Zig kann Hot-Code-Reloading. Bei VS kam das fĂŒr C++ erst in VS 2022. .NET kann es auch seit Version 6.
Neuerungen: Generics und ein any-Keyword fĂŒr interface{}. Damit sollte quasi jedes Go-Projekt ungefĂ€hr um die HĂ€lfte schrumpfen.
Achja, und sie haben jetzt einen Fuzzer, den man fĂŒr Tests verwenden kann. Hier ein kleines Tutorial.
Gerade ist dieses Peoposal in meiner Timeline aufgetaucht. Ein Author ist Daniel Rosenwasser, bekannt aus dem TypeScript-Projekt.
Idee: einen GroĂteil der TS-Syntax in JS aufnehmen, allerdings ohne TypĂŒberprĂŒfung. Die Type-Annotations sollen von der Engine komplett ignoriert werden, ist also an der Stelle Ă€hnlich zu dem Type-Hints aus Python. Nur kann man bei Python noch zur Laufzeit auf die Typen zurĂŒckgreifen. Das wĂŒrde hier auch entfallen.
Als MS mit TypeScript angefangen hat, hĂ€tte Anders geĂ€uĂert, dass statische Typen in der JS-Welt nicht gern gesehen sind - zumindest nicht in der Kernsprache. In dem Proposal ist ein Screenshot aus The-State-Of-JavaScript. Dort wĂŒnschten sich die Teilnehmer der Umfrage - mit Abstand - statische Typisierung am meisten. Das sieht fĂŒr mich aus, als hĂ€tte MS da eine ziemliche Erfolgsstory mit TypeScript hingelegt.
Das Proposal wurde nichtmal dem TC39 vorgelegt - es wird also noch sehr lange dauern, sollte etwas in dieser Richtung kommen. Falls es kommt, wĂ€re das ein ziemlicher Game-Changer. Man erspart sich damit, .d.ts-Dateien mit auszuliefern. Da JS dann gröĂtenteils quasi das ist, was TS heute ist, wird TS dadurch deutlich zurĂŒck gehen und vorrangig nur noch als Type-Checker fĂŒr JS dienen. Es wĂŒrde tatsĂ€chlich vieles vereinfachen.
Spannend!
So you want to design a programming language?
Der verlinkte BNF-Editor ist auch schön anzusehen.
On finding the average of two unsigned integers without overflow.
EnthÀlt auch eine (ehemalig) patentierte Variante.
Gut gefÀllt mir auch der untere Part:
Bonus chatter: C++20 adds a std::midpoint function that calculates the average of two values (rounding toward a). Bonus viewing: std::midpoint? How hard could it be? (Vortrag geht eine Stunde)
A Language Design Analysis of HolyC (das ist die Sprache von TempleOS)
Interessanter Post: Why asynchronous Rust doesnât work
Go 1.18 kommt mit Generics. Interessant ist auch der built-in Fuzzing-Support.
Wo wir gerade bei JSON waren und jetzt kommt âdann nehmâ ich einfach YAML, das ist ganz einfach und man kann es auch einfach parsenâ. YAML ist ein Superset von JSON. Das heiĂt, dass wir alle JSON-Probleme weiterhin haben.
Dazu kommt, dass das restliche Format auch nicht so gut ist. Hier wieder ein bekannter Blogpost: YAML: probably not so great after all.
Ein Zitat aus dem Post:
YAML may seem âsimpleâ and âobviousâ when glancing at a basic example, but turns out itâs not. The YAML spec is 23,449 words; for comparison, TOML is 3,339 words, JSON is 1,969 words, and XML is 20,603 words. [âŠ] For example did you know there are nine ways to write a multi-line string in YAML with subtly different behavior?
YAML hat auch ein berĂŒhmtes Problem. Ihr könnt ja mal ĂŒberlegen, was man hier nach dem Parsen erhĂ€lt:
countries:
- GB
- IE
- FR
- DE
- NO
- US
Dann probiert es jetzt aus, oder schaut in den verlinkten Artikel.
Sowas Ă€hnliches ist auch der Grund, warum man bei docker-compose-Files die Port-Mappings immer in AnfĂŒhrungsstriche schreiben sollte.
Aus der âBekannte Blogpostsâ-Serie: What Color is Your Function?
Man stelle sich vor, Programmiersprachen haben zwei Arten von Funktionen: Rote und Blaue. Dazu kommen Regeln, wie man sie kombinieren kann. Am Ende sieht man, worum es eigentlich geht. Haben wir sicherlich alle schon einmal benutzt.
Ich mag ja coole und vor allem verrĂŒckte Ideen fĂŒr Programmiersprachen.
Hier ist eine fĂŒr Musik, hier ein Tutorial.
Codeausschnitt:
trumpet: (tempo 200) o4 c8 d e f g a b > c4.
trombone: o3 e8 f g a b > c d e4. Gerade ist eine neue .NET-Preview veröffentlich worden. Bis auf ein paar Library-Neuerungen ist vor allem eines neu: Statische Interface-Member.
Damit kann man diverse Patterns, wie z. B. Parse + TryParse jetzt als Interface-Methoden definieren (das ging vorher nicht, weil die beiden Methoden statisch sind und Interfaces auf Instanzmethoden beschrÀnkt waren). Jetzt geht das.
Damit lĂ€sst sich jetzt sehr viel machen, z. B. mathematische Operatoren ĂŒber generische Interfaces zu definieren. Dann kann einer Library egal sein, welchen Typ man reinwirft, hauptsache er âkann Additionâ (ĂŒberladene Operatoren sind auch statische Methoden, deshalb ging das bisher nicht). NatĂŒrlich gehen auch Vergleichsoperatoren, die bisher ĂŒber das IComparable<T>-Interface liefen.
Wenn man da jetzt die Mathematiker drauf lÀsst, bekommt man sicher ganz viele Gruppen, Monoiden, Ringe, Körper und noch ganz andere viele Dinge. Ich hoffe, dass der JIT damit ordentlich umgehen kann. Bei den Gleichheitsoperatoren fÀllt mir jetzt auf, dass sie nicht zwischen Partieller Gleichheit und totaler Gleichheit unterscheiden, wie Rust das macht. Generell wirkt es etwas, wie Concepts aus C++. Vielleicht ein bisschen weniger mÀchtig.
Ein weiterer Blog-Post, den viele kennen: PHP: a fractal of bad design
Ist auch schon etwas Ă€lter (2012). In der Zeit hat sich fairerweise auch schon viel getan. Das meiste ist aber irreversibel in der Sprache verankert. Versteht mich nicht falsch, ich will hier ein sinnloses PHP-gebashe betreiben. Man kann PHP durchaus fĂŒr Dinge verwenden. Es ist halt eine von vielen möglichen Lösungen.
Seit .NET 5 gibt es in C# ein Sprachfeature, mit dem man Code generieren kann, basierend auf dem C#-Code, der schon da ist.
Das öffnet vielen Dingen die Tore, z. B.:
- Dependency Injection zur Compiletime (statt Runtime); dadurch schnellere Startzeit
- Spezialisierte (JSON-)Serialisierungs-Typen, die genau einen bestimmten Typen (De-)Serialisieren können
- Ganz viel Reflection fÀllt weg
Eigentlich ist Code-Generation gar nicht so toll. Man hat am Ende Zeug, das man nicht ordentlich debuggen kann und im Zweifelsfall ist der Fehler im Code-Generator. Sowas ist auch immer ein Zeichen dafĂŒr, dass die Sprache nicht ausdrucksstark genug ist. AuĂerdem habe ich bisher schlechte Erfahrungen damit gemacht (ok, eigentlich nur in Java). Da hat man immer mal wieder das Problem, dass generierter Code (z. B. von immutables.org) ânoch nicht da istâ und die IDE dann meckert, warum man eine nicht-existente Klasse verwendet (in diesem Fall z. B. der Builder fĂŒr einen unverĂ€nderlichen Typen).
Man sieht aber trotzdem den Use-Case fĂŒr solche Dinge. Da C# sich aktuell stark darauf hinentwickelt, Ahead-Of-Time-Compile-fĂ€hig zu sein, ergibt dieses Feature Sinn. Z.B. ist Reflection bei AOT-Kompilierung ein Dorn im Auge, da man nicht weiĂ, welche Typen/Codeteile man aus der fertigen Assembly rausschmeiĂen kann. Man kann auĂerdem sehr schön optimieren, wenn man konkreten Code mit ordentlichen Typen statt Reflection hat.
Vermutlich werden viele Dinge, die C# vor ein paar Jahren noch als eigenes Feature gebaut hĂ€tte, jetzt als Source-Generator implementiert. Letztendlich ist das ja auch nur ein Compiler-Plugin, das Lowering betreibt. Hoffentlich wird es die Sprache nicht allzu krass verwĂ€ssern. Die BefĂŒrchtung habe ich ja schon.
Hier ist eine Liste mit Source-Generatoren, die man sich in einer freien Minute anschauen kann. Viel Zeug dabei, das man nicht braucht. Aber auch viel nĂŒtzliches.