C#:ManagedCode
Designed by Anders Hejlsberg at Microsoft in 2000 with the muscle memory of Turbo Pascal and Delphi. Twenty-five years on, C# still anchors enterprise back ends, Unity games, and cross-platform UI simultaneously — and the originals of async/await, LINQ and record that every other language eventually copied? They were first shipped here.
C# 1.0 ships in 2002
.NET 10 LTS, 2025-11
near-monopoly on mobile
long-time top-5
What is C#
C# is a statically typed, object-oriented, component-oriented modern language designed by Anders Hejlsberg at Microsoft (announced 2000, GA 2002). Born as Java's mirror sibling; 25 years on, it ships in three deployment shapes (JIT / Tiered / AOT) on four OSes, anchoring three major industry fronts.
Runs on the CLR with GC + JIT + reflection + strong types. Rare in 2000, baseline by 2026 — but C# was one of the very first industrial languages to standardise on it.
In 2007, C# 3 baked query syntax into the language itself: from / where / select as native keywords, also usable as a fluent chain. No same-era Java / C++ matched this.
C# 5 (2012) was the first industrial-language landing of async/await. TypeScript copied it 3 years later, JS 5 years later, then Python / Rust / Swift in turn. C#'s largest export.
.NET Core in 2014 pried C# loose from Windows-only; .NET 5 in 2020 merged the three forks. The 14-year-old "C# is a Windows language" label is no longer used in 2026.
public class Hello {
public static void main(String[] args) {
List<Integer> xs =
Arrays.asList(1,2,3,4);
int sum = 0;
for (int x : xs)
if (x % 2 == 0) sum += x * x;
System.out.println(sum);
}
}
// Java 7 era: three nesting levels + manual for + one println// top-level statements — no class boilerplate
int[] xs = [1, 2, 3, 4];
var sum = xs
.Where(x => x % 2 == 0)
.Sum(x => x * x);
Console.WriteLine(sum);
// one file = the entire program
// LINQ + collection expression + top-level mainThe Hejlsberg lineage : 4 languages · 4 eras
One person, 40 years, four languages — and each redrew the tooling of its era. Turbo Pascal taught a generation that "compilers can be fast"; Delphi popularised RAD on Windows; C# is the centre of the lineage; TypeScript took over the JavaScript era. No second name in language design carries a comparable resume.
"When we designed C# we already knew the price of static typing + GC + JIT was the "slow startup, heavier memory" tax. But looking back 25 years, the bet was right — it's the optimal shape for most industrial apps, not scripts and not C/C++. We made the same bet on TypeScript later, and that was right too.
History : Timeline
Twenty-six years through four eras: .NET Framework (Windows-only, 2002–2014) → Mono / Xamarin (the community drag off Windows, 2004–2016) → .NET Core (Microsoft's own cross-platform run, 2014–2020) → Unified .NET (2020 onward). Each step is stamped on the language's version number.
- 1996·11
Anders Hejlsberg jumps from Borland to Microsoft
Hejlsberg, then chief designer of Turbo Pascal and Delphi, is reportedly hired with ~$3M of options plus multi-million retention. Borland sues, settles, Microsoft keeps him — the actual Chapter 0 of the .NET story.
- 2000·06·26
C# unveiled at PDC 2000
At Microsoft's Professional Developers Conference, Hejlsberg's "Project Cool" goes public. The internal name was "COOL" (C-like Object Oriented Language), renamed C#. The design brief is unembellished: "give Windows a modern managed language like Java, but make it fast, ergonomic, and able to call into COM".
- 2002·02·13
.NET Framework 1.0 + C# 1.0 GA
Ships the same day as Visual Studio .NET. CLR (Common Language Runtime), JIT, GC, BCL all show up in one slab — later than Java's JIT, but generics weren't bolted on, lifetimes weren't manual; it was a managed language from day one. Windows-only · but production-grade out of the gate.
- 2004·06·30
Mono 1.0 — .NET on Linux/macOS
Miguel de Icaza (founder of GNOME) ships Mono 1.0: a from-scratch reimplementation of CLR + BCL on Linux / macOS / BSD. The crack that turned C# from a Windows language into a "cross-platform in theory" language; the real cross-platform story has to wait for Microsoft itself in 2014.
- 2005·11
C# 2.0 — generics / iterators / nullable / partial
Generics are reified at the CLR level (Java went with erasure);
List<int>is genuinelyList<int>at runtime.yield returnturns iterators into one-liners;int?is nullable value types;partial classstops the WinForms designer from clobbering your code. - 2007·11
C# 3.0 / LINQ — the personality shift
The first identity rewrite:
var, lambdas, extension methods, object initialisers, anonymous types, expression trees — all of it in service of LINQ.from x in xs where x > 0 select x * 2sits inside the language. SQL-in-memory, set algebra as a daily tool. JS, Java and Swift only caught up over the following decade. - 2010·04
C# 4.0 —
dynamic/ named args / variancedynamichooks into the DLR (Dynamic Language Runtime), letting C# call into Python / Ruby-style dynamic objects. Named and optional parameters wipe out half the overload boilerplate. By this point C# is two versions ahead of Java — but it's still stuck on Windows. - 2012·08
C# 5.0 —
async/awaitC# brings async/await to the mainstream: a state-machine rewrite of continuation passing that reads like synchronous code. TypeScript copies it three years later, JavaScript (ES2017) five years later, then Python, Rust, Swift all follow — this is C#'s single biggest gift to the industry.
- 2014·04·03
Roslyn open-sourced — the compiler as a service
At Build 2014, the entire C# / VB.NET compiler goes open source (Apache 2.0), codenamed Roslyn. Its "compiler-as-a-service" API lets IDEs, linters and code-fixers reuse the official syntax tree for the first time. The same year Satya Nadella takes over as CEO and Microsoft pivots 180 degrees on open source — this is the opening shot.
- 2014·11·12
.NET Core announced — cross-platform, open source
At Connect(); 2014, .NET Core is officially launched: MIT licence, public on GitHub, targets Windows / Linux / macOS. "Microsoft loves Linux" — Nadella's slogan is born here. For C# it means one thing: it is no longer a Windows language.
- 2016·06·27
.NET Core 1.0 GA + Xamarin acquisition
.NET Core 1.0 ships. Earlier that February, Microsoft acquires Xamarin (the commercial parent of Mono); Miguel de Icaza moves in-house, and the Mono / Xamarin runtimes are absorbed. The two cross-platform tracks of .NET merge into one this year.
- 2019·09
C# 8.0 — nullable reference types + async streams
Nullable reference types catch "mother of all NullReferenceExceptions" at compile time (opt-in via
#nullable enable);IAsyncEnumerable<T>+await foreachwelds async to iterators. Static typing takes one more practical step forward. - 2020·11·10
.NET 5 — three forks finally merge
.NET Framework (classic Windows) + .NET Core (cross-platform) + Mono / Xamarin all collapse into a single .NET. Version 4 is skipped to avoid clashing with Framework 4.x. One SDK, one runtime family. The biggest single-step consolidation .NET has had in 18 years.
- 2020·11
C# 9.0 — records / top-level / pattern matching
recordtypes: an immutable value object with autoEquals/GetHashCodein one line; top-level statements compress hello world to two lines; second-generation pattern matching (is { Prop: 1, Other: > 0 }). C# starts to taste like a modern ML-flavoured language. - 2022·11
.NET 7 — Native AOT (preview)
Native AOT compiles a .NET app to a single native binary: no JIT, millisecond startup, smaller images — a direct play for Go's "small services, CLIs, container-first" territory. The language stays put; the runtime shape changes.
- 2023·11·14
.NET 8 LTS — Native AOT GA · Blazor full-stack
Native AOT goes GA with full support in ASP.NET Core Minimal API; Blazor United unifies Server and WebAssembly rendering modes, letting one C# code path run end-to-end. LTS — the version most enterprises actually base their migrations on for the next half-decade.
- 2024·11·12
.NET 9 — params collections / Span perf
params ReadOnlySpan<T>makes variadic calls zero-allocation; multiple LINQ hot paths get rewritten and the JIT pushes harder on SIMD and loop unrolling. Another marker on the road of "tuning .NET until single-core perf goes head-to-head with Rust". - 2025·11·11
.NET 10 LTS — the present steady state
New LTS, C# 14: the
fieldkeyword removes the boilerplate of manual backing fields for properties;extensiontypes preview (Hejlsberg's extension methods v2 from the LINQ era). Native AOT becomes default in several templates, container images keep shrinking. Unity 6.1 catches up to .NET 9 LTS. 2026 enterprise production lines sit on this. - 2026
26 years in — global top-5, enterprise + games + cross-platform
C# in 2026: long-time top-5 on TIOBE / IEEE / RedMonk; the steady backbone of enterprise back ends, especially in North America and Europe; Unity remains the #1 scripting language in the games industry (most surveys hover at a 60–70% in-use rate); MAUI delivers "one C# codebase, four OSes"; Blazor / WASM keeps climbing on the front end. Hejlsberg shifted focus to TypeScript back in 2012, but C# now sustains itself.
.NET version ribbon : Framework · Core · Unified
C# is the language, .NET is the runtime it lives on — and .NET has worn three different faces over 25 years. One line per version below; only the ones that actually moved the game, not every minor.
CLR 1.0 + BCL · Windows onlynullable · first version that genuinely scaledasync/await arrives · language pulls ahead, framework lagsglobal using · backbone of production lines through 2024params ReadOnlySpan · LINQ speedup · SIMD progressfield · extension preview · current production LTSLanguage Essentials : CsharpAlphabet
Eight cards plus one wrap-up — the moves where C# genuinely pulled ahead: LINQ (2007 original), async/await (2012 original), records & pattern matching, top-level statements, nullable refs, the Span<T> systems-programming off-ramp, and source generators.
LINQ — from / where / select
In 2007, LINQ pushed query syntax into the language itself: one where / select / group by set runs over in-memory List<T>, and translates to SQL via Entity Framework Core. The move that pulled C# clear of its Java / C++ contemporaries.
var adults = from p in people
where p.Age >= 18
orderby p.Name
select new { p.Name, p.Age };
// fluent shape — same thing, no query syntax
var adults2 = people
.Where(p => p.Age >= 18)
.OrderBy(p => p.Name)
.Select(p => new { p.Name, p.Age });async / await — C#'s industry export
C# 5 in 2012 brought async/await to a mainstream industrial language. It reads synchronously; underneath it's a state machine. Async I/O looks like sync I/O. TypeScript → JS → Python → Rust → Swift all copied it.
async Task<string> FetchAsync(string url)
{
using var http = new HttpClient();
var resp = await http.GetAsync(url);
return await resp.Content.ReadAsStringAsync();
}record — immutable value object in one line
C# 9 (2020): a single record declaration gives you Equals / GetHashCode / ToString / with-expressions for free, with value semantics handled by the CLR. The peer to Kotlin's data class.
public record Point(double X, double Y);
var a = new Point(1, 2);
var b = a with { Y = 3 };
Console.WriteLine(a == new Point(1,2)); // TruePattern matching — not just switch
From C# 7 onward: switch expressions, property patterns, relational patterns. Switch is no longer a branching statement; it's an expression. Combined with record you can write near-ML / F# style algebraic code.
string Classify(Point p) => p switch
{
(0, 0) => "origin",
(var x, 0) => $"x-axis @ {x}",
{ X: > 0, Y: > 0 } => "Q1",
_ => "elsewhere"
};Top-level statements — two-line hello world
From C# 9 a file can open with Console.WriteLine directly — no class Program, no static void Main. The "first program a student sees" finally stands at the same starting line as Python or JS.
// Program.cs — the entire app
Console.WriteLine("Hello, C#");
var name = Console.ReadLine();
Console.WriteLine($"Hi, {name}!");Nullable reference types
Opt into #nullable enable and string? versus string become two different types at compile time; dereferencing without a check is a build error. Cuts the 26-year-old NullReferenceException joke in half.
#nullable enable
string? Find(int id) => null;
var n = Find(7);
Console.WriteLine(n.Length); // warn: possibly null
if (n is not null)
Console.WriteLine(n.Length); // fine, flow-typedSpan<T> — zero-alloc stack buffer
Span<T> / Memory<T> (since .NET Core 2.1) are C#'s systems-programming off-ramp: stack-allocated, zero-alloc, slice a string / byte buffer without copying. By 2026 most hot-path JSON parsers and HTTP framing code is built on them.
static int SumDigits(ReadOnlySpan<char> s)
{
int sum = 0;
foreach (var c in s) sum += c - '0';
return sum;
}
SumDigits("12345".AsSpan(1, 3)); // no allocSource generators — compile-time metaprogramming
From 2020, Roslyn exposes a source generator API: read the AST at compile time, emit new source files, compile together. Replaces the old IL-weaving and runtime-reflection style for hot paths; JSON, gRPC, Regex and DI frameworks all use it to zero the reflection tax.
// JSON serializer, compile-time generated
[JsonSerializable(typeof(Point))]
partial class MyJsonCtx : JsonSerializerContext { }
var json = JsonSerializer.Serialize(
new Point(1, 2), MyJsonCtx.Default.Point);C# 14 (.NET 10) — what's in your hands today
Released 2025-11, LTS support through 2028. The field keyword finally names the hidden backing field of a property; extension types preview (extension methods v2, this round adding properties, statics, operators); collection expressions GA'd in .NET 9 and are extended language-wide in .NET 10. The argument-null-check operator !! remains unshipped after years of debate — LDM's reason: "clarity gain is too small."
"What goes in — and what doesn't — is decided in the open by Mads Torgaard's Language Design Meeting (LDM): Wednesdays NA time, notes pushed to GitHub."
Why C# : WhyCsharp
C# isn't a hype language (no Rust-grade "zero-cost abstraction" halo, no Mojo-grade 35,000× number) and isn't a hello-world language (it sits on three layers of LSP / Roslyn / CLR infrastructure). It's the "once you've used it, it's hard to leave" kind — typed + LINQ + async/await + Roslyn fused, the most comfortable rung for the majority of industrial-app shapes.
Holds three fronts at once
Few languages anchor enterprise back ends, games and cross-platform mobile simultaneously — C# does. ASP.NET Core for enterprise APIs, Unity (~70% in-use across the games industry), MAUI / Avalonia across four OSes — one language, all three.
// asp.net core minimal api
var app = WebApplication.Create(args);
app.MapGet("/", () => "hi");
app.Run();JIT + AOT + Native — three deployment shapes
One C# codebase can run as JIT (default) for long-lived services, Tiered JIT that recompiles hot paths, or Native AOT to a single binary with Go-class startup. Java, Kotlin and Go each ship only part of this matrix.
# build a tiny single-file native binary
$ dotnet publish -c Release \
/p:PublishAot=true \
/p:StripSymbols=trueRoslyn — compiler as a service
In 2014 Microsoft open-sourced the entire C# / VB.NET compiler as an API, not a black box. Every squiggle, quick-fix and source generator is a third-party plugin riding on Roslyn. JetBrains Rider and the VS Code C# Dev Kit are both built off this hand.
// roslyn API, in C# itself
var tree = CSharpSyntaxTree.ParseText(src);
var root = await tree.GetRootAsync();
foreach (var m in root.DescendantNodes()) ...Hejlsberg's track record — 4 languages, 4 eras
Turbo Pascal (1983) → Delphi (1995) → C# (2000) → TypeScript (2012). Each defined its era's tooling; one person spans 40 years of industrial language history — a track record without peer in the field.
// 1983 Turbo Pascal — IDE + compiler for $49
// 1995 Delphi — RAD on Windows
// 2000 C# — managed code for the masses
// 2012 TypeScript — types for JavaScriptA paycheck language
By 2026 C# / .NET sits alongside Java in hiring demand across North America, Europe and India, with average salaries only slightly behind Rust and Go among statically-typed languages. Stack Overflow's "most-used × highest-paid" overlap year after year. Not a hype language; a paycheck language.
// stackoverflow survey · 2024
// C# — top-5 most used · top-10 paid
// .NET — top-3 web framework cohortThree universes : One language, three worlds
C# is unusual in that it lives in three developer universes that barely speak to each other. One person does Unity games, another writes ASP.NET Core APIs, a third builds MAUI mobile apps. They rarely cross over — yet all three are C# developers.
Games / Unity
Unity picked C# as its scripting language in 2005 and never looked back. Near monopoly on mobile games; the default starting point for mid-tier PC, VR, AR and indie. Unreal uses C++ / Blueprint, Godot uses GDScript — but C#'s "two-hour onboarding" path has no real replacement.
- Unity 6 · 2026
- ~70% market
- scripts == hot reload
- IL2CPP backend
Enterprise web / ASP.NET Core
The steady backbone of large-enterprise back ends in North America, Europe and India. Stack Overflow famously runs on .NET; Microsoft / Bing / Azure / LinkedIn ship vast amounts of ASP.NET Core; banks, insurers, governments and healthcare systems sit on .NET 6/8/10 LTS. Not splashy, not trending — paycheck language.
- ASP.NET Core
- Minimal API · gRPC
- EF Core · Dapper
- Azure first-class
Desktop + cross-platform UI
Three threads coexist: WPF / WinForms (classic Windows, hundreds of thousands of enterprise systems still maintained), MAUI (Microsoft's official four-OS cross-platform, stable in 2026), Avalonia (community-led WPF-API clone + cross-platform; JetBrains Rider itself runs on it). Less fashionable than web, but the lane is still open.
- WPF · WinForms
- MAUI 4-OS
- Avalonia OSS
- Uno Platform
Minimal API + Native AOT
The 2026 hello-world: one file, five lines, a single ~10 MB native binary, ~20 ms cold start, no JIT, no GC pause to speak of. This barely looks like the ASP.NET monolith of five years ago.
- Minimal API — Lambda-style endpoint registration
- Native AOT — Compiles to a single binary, no JIT
- System.Text.Json — Source-generated, no reflection
- Trimming — Unreferenced library code is removed
Rivals: Go and Rust in container-first microservices. Not a replacement for the ASP.NET monolith — a new lane for "small, cold-start, density-sensitive" services.
// Program.cs — the entire microservice
using Microsoft.AspNetCore.Builder;
var app = WebApplication.Create(args);
app.MapGet("/", () =>
new { msg = "hello, AOT" });
app.MapGet("/sum", (int[] xs) =>
xs.Sum());
app.Run();
// $ dotnet publish -c Release /p:PublishAot=true
// → 10 MB · 20ms cold start · 0 JITMultiple industry surveys (Unity Technologies, GDC State of the Industry) put Unity at 60–70% active use year after year. It is C#'s genuinely "no replacement yet" niche: mobile games 95%+, with indie, mid-tier PC, VR and AR as defaults.
By 2026 NuGet (.NET's npm) lists about 6 million unique versions across ~400k unique packages. Smaller than Maven Central or npm, but extremely complete across the enterprise domain — logging, DI, EF, web, cloud. It's not raw size, it's that "every enterprise use case has a ready wheel".
One C# source tree, three runtime behaviours: long-lived services use JIT, hot paths get re-tiered by Tiered JIT, startup-sensitive lambdas / CLIs use Native AOT. That "same language, three shapes" flexibility — Java, Kotlin and Go each ship only part of it.
2026 .NET ecosystem mainstays
LLMs writing C# — plenty of data, with caveats
C# / .NET has no shortage of training data — millions of .NET repos on GitHub and a top-5 Stack Overflow tag — and GPT / Claude write C# with fluency close to Java / Python. But two real-world traps stand out.
First: models often default to .NET Framework / older Core syntax, because the training corpus skews old. Getting them to produce .NET 8/10 Minimal API / records / patterns usually requires explicit version hints.
Second: Roslyn analyzers and source generators are where LLMs reliably stumble — C#'s real "AI weak spot." Metaprogramming evolves at the pace of the LDM, and the training corpus lags by 12+ months. This layer is still hand-written.
// ❌ LLM default (older .NET Core / Framework)
public class Startup {
public void ConfigureServices(IServiceCollection s)
{ ... }
}
// ✅ modern (.NET 8/10 Minimal API)
var b = WebApplication.CreateBuilder(args);
b.Services.AddSingleton<IFoo, Foo>();
var app = b.Build();
app.MapGet("/", (IFoo f) => f.Greet());
app.Run();In one line: C# is one of the few languages in 2026 that simultaneously anchors enterprise, games, and cross-platform UI. It doesn't go viral, but it has been in production for 24 years — and the 2026 version is not the 2002 Windows language. Native AOT, Blazor United, MAUI, records, patterns, Span<T>, source generators — it's evolving, not aging.
Who's Using : ProductionUsers
Twelve cards below, every one a project still in production in 2026: Microsoft's own .NET / ASP.NET / Roslyn, Unity (scripting monopoly), Blazor (front-end), VS Code / Rider (tooling), PowerShell, Stack Overflow (public case), EF Core / Avalonia (ecosystem).
vs Java / Kotlin : Csharp vs Java vs Kotlin
The mirror sibling of Java 25 years back, and the "modern JVM peer" of Kotlin from the 2010s. Putting all three in one table makes alignment versus divergence obvious.
| Java | C# | Kotlin | |
|---|---|---|---|
| Origin | Sun · 1995 | Microsoft · 2000 | JetBrains · 2011 |
| Designer | James Gosling | Anders Hejlsberg | Andrey Breslav · JB team |
| Primary runtime | JVM (HotSpot / GraalVM) | .NET CLR (JIT / Tiered / AOT) | JVM + Native / JS / WASM |
| Generics implementation | Erasure · invisible at runtime | Reified at the CLR | Erasure (JVM compat) · inline reified |
| LINQ-style collections | Stream API (Java 8) · 7 yrs late | Originated it · 2007 | Sequence + extension fns · similar |
| async/await | Virtual threads (Java 21) · different model | Originated it · 2012 | Coroutines · equivalent, lighter |
| Nullability | Optional<T> · not in type system | Opt-in #nullable · type-level | T? default |
| record / data class | record (Java 16) · 5 yrs late | record · 2020 | data class · 2016 |
| Pattern matching | 2024+ gradually added | switch expression · expression-level | when expressions |
| Compile-time metaprogramming | Annotation processing · ancient | Roslyn source generators (2020) | KSP (Kotlin Symbol Processing) |
| Mobile | Android (legacy) | MAUI · Unity (games) | Official Android + KMP iOS |
| Cross-platform UI | JavaFX (waning) | MAUI + Avalonia + WPF/WinForms | Compose Multiplatform |
| 2026 dominant use | Enterprise backend / Android | Enterprise / games / cross-platform UI | Android / server-side (Spring Boot) |
| Open source | OpenJDK · GPL2 + CE | Roslyn + .NET runtime · MIT | Compiler Apache 2.0 |
Outlook : TheRoadAhead
C# in 2026 has no "1.0 hype" and no "about-to-die" feel — what it's doing is quietly tightening every industrial front it already holds: Native AOT moving on small services, Blazor United going full-stack, MAUI finally stable, Unity unmoved, Hejlsberg himself off on TypeScript.
Native AOT everywhere — coming for Go / Rust microservices
Native AOT went GA in .NET 8 and ships on-by-default in several .NET 10 templates. Startup drops from seconds to milliseconds, image size from ~70 MB to ~10 MB, and the GC is still there but without big generation pauses.
What it means: C# can finally compete head-on with Go / Rust on container-first microservices. Big-shop ASP.NET Core APIs deployed to Lambda / Cloud Run are migrating in bulk — not a replacement for JIT, just a new lane for "small, fast, cold-start" apps.
Blazor United — full-stack in C#
From .NET 8, Blazor merges its two rendering modes — Server (SignalR over WebSocket) and WebAssembly (.NET in the browser). Components render server-side first, then hydrate client-side. Architecturally close to Next.js / Nuxt with RSC, but in C#.
Why it matters: no more "TS on the front, C# on the back" split — one codebase end-to-end. Audience: orgs already on the .NET stack who don't want to maintain a second JS team.
MAUI — one codebase, four OSes
.NET MAUI is the Xamarin.Forms heir: one XAML + C# project building for iOS / Android / macOS (Catalyst) / Windows. Two rounds of "stability cleanup" through 2024–2026 finally bring it to production-ready.
Rivals: Flutter (Dart), React Native (TS), Avalonia (community C#). MAUI's edge is the "I already know C#" engineer, not "easy for newcomers."
Unity isn't going anywhere
Unity's 2023 install-fee crisis sent some studios to Godot or Unreal, but Unity still owns 60–70% scripting share in 2026: mobile games are near-monopoly, indie / mid-tier PC / VR / AR are still the default starting point. No replacement for C# is visible on the horizon in this lane.
Drifting away from Java
In 2002 C# and Java were mirror siblings; in 2026 they are two distinctly different languages. C# went all in on records, patterns, async, Span; Java's virtual threads / sealed types / records (five years late to C#) are catching up but never aligning. Who wins? Depends which side you measure: Java's server footprint and ecosystem are still vast; C#'s language pace and integrated tooling still lead.
Hejlsberg himself — already on TypeScript
An interesting footnote: by 2012 Hejlsberg had moved his main focus to TypeScript. His title at Microsoft is "language architect," and C#'s evolution has long been steered by the LDM team under Mads Torgaard. One person stewarding both C# 1.0 and TypeScript 1.0 within twelve years is extraordinarily rare in industrial language history.