I started my career doing ~20 years of C# from pretty much the very beginning (JavaScript even before then!).<p>Around 2020, I switched into the startup space and quickly picked up TypeScript since that's "what the kids use". It wasn't without struggles, but once I wrapped my head around TypeScript as "shapes for JavaScript", it clicked.<p>At the time, the startup was undertaking a new product built on Nest.js[0] which looked awfully similar to ASP.NET web APIs which had the benefit of being much more mature, complete, and with one of the best ORMs (EF Core). I suggested it to the team and was a bit shocked by the pushback.<p>It ultimately inspired me to do a bunch of writing [1][2] on just how similar these two languages are and how they've converged on syntax (no doubt owing to Anders at the helm). Of course, they ultimately still have quite a bit of a gap, but for teams that are working in TS and finding that they are outgrowing it, C# is a very natural choice.<p>I left that startup after a short stint, but boomeranged almost 3 years later. Company went from seed to series C in that time. End of last year, we started the migration from TypeScript on the backend to C# on the backend and haven't looked back. The toolchain is far simpler and stable, the "default" ORM is far more flexible and powerful, the more rigorous type chain seems more conducive for agent-driven coding. Team adapted relatively quickly within ~4 weeks.<p>[0] <a href="https://nestjs.com/" rel="nofollow">https://nestjs.com/</a><p>[1] <a href="https://typescript-is-like-csharp.chrlschn.dev/" rel="nofollow">https://typescript-is-like-csharp.chrlschn.dev/</a><p>[2] <a href="https://itnext.io/getting-functional-with-c-6c74bf279616" rel="nofollow">https://itnext.io/getting-functional-with-c-6c74bf279616</a>
I can't say for sure because I don't know the full situation, but I've heard a similar story a few times and IMNSHO looking at it as "they made the wrong choice initially" is off because it assumes that a C# team could have delivered the initial version in the timeline required to get to the the next level of project.<p>If they had a team that knows nest and can iterate fast with it that's the perfect choice. I've worked at multiple agencies over the years and was mostly in C# teams. Whenever a C# team got on greenfield/startup projects it ended up being a shit-show of self inflicted slowdowns/over-complications. I've seen 3 projects where in large part due to slow development of the MVP the project missed investment window or ran out of funds.<p>From my experience Node/Rails teams were much more capable of delivering shit that works. It would eventually have a bunch of problems that would be non issues by default on a different stack like ASP.NET, but the difficulty of getting to that point and realizing that just being in that situation is a win is what most engineers miss.
Same experience here. C# might have superior tooling, performance, whatever but the OOP baggage is too heavy. In theory you can write something else than a giant over-complicated, over-abstracted pile of OOP nonsense in C#, but every team I've seen <i>has</i>.
I assume the startup wasn't also leveraging typescript heavily on the frontend, that tends to shift the weight in its favor. Having one set of tools to use across everything, being able to share logic and types without needing to go through lossy translation layers, and giving (especially small) teams better flexibility to move people around is a huge benefit.
> <i>the "default" ORM is far more flexible and powerful</i><p>I have never used any ORM that is as capable. Entity Framework Core with Linq is what keeps me on .NET.
Surprising to me that (in the context of TypeScript) ECMAScript 4, ActionScript, and Google Closure were not mentioned! Especially the first two; Macromedia/Adobe and Netscape/Mozilla have been working on baking TypeScript into JavaScript proper for a whole decade before HTML5, the mobile boom, and the associated problems have emerged. ES4/AS3 even had a nearly identical syntax.<p>What's even more interesting is that Microsoft and Google were part of TC-39 at the time, and were the main opponents of ES4. While they had some rightful reasons to take this position, there's no way ES4 hasn't shaped TS in the end. Perhaps the lack of mention of any of this is due to that TypeScript might have been handed to Anders' team after the project vision and original design have developed (in the video, it is introduced as a continuation of "SharpScript"), but the interview still left me rather insatiated.
> <i>ES4/AS3 even had a nearly identical syntax.</i><p>Yeah. As someone who lived that era it was so frustrating that they abandoned ES4. I used AS3 daily for almost a decade until Adobe abandoned ActionScript4 and Flash Next around 2015.
Out of the big 4 involved in typescript, only one was involved with the tc39
I watched this last week.<p>The part about veering constantly to navigate the maze of internal politics is fascinating. The compromises he had to make, like not being able to put in on Github initially. The easy victories, like making TypeScript open source.<p>The long road to success. The obligatory advice for people writing new programming languages (Hint: Mostly, don't.). His opinion about creating a new language for AI (I agree with his insight, but still think it is possible).<p>Overall, well worth watching.
I used to dream about a TypeScript that targeted dotnet. These days I'm not so sure I'd use it, only because I have a tendency to get caught in the weeds "big braining" the type system to make the perfect type for every situation. F# is my happy medium for the backend.
The real history of C# is that it is a rip off of Java. Anders / Microsoft understandably doesn't want to acknowledge that, but the rest of us can. C# today has diverged from Java, but the original release was Java with a few features added, such as properties, delegates, structs and unchecked exceptions.<p>That last one was a mistake, see <a href="https://mckoder.medium.com/the-achilles-heel-of-c-why-its-exception-handling-falls-short-f7f932488aba" rel="nofollow">https://mckoder.medium.com/the-achilles-heel-of-c-why-its-ex...</a>
MS poached him (and was even sued for it - that's how egregious it was) to create a Java killer because they had issues with Java.
> "Hejlsberg: First of all, C# is not a Java clone. ... we looked at lots of languages, we looked at Java"<p>- <a href="https://web.archive.org/web/20100109195800/http://windowsdevcenter.com/pub/a/oreilly/windows/news/hejlsberg_0800.html" rel="nofollow">https://web.archive.org/web/20100109195800/http://windowsdev...</a><p>You can just state the author of the language is lying and you somehow know better. You don't even justify <i>why</i> "they don't want to acknoweldge it" - even with Hejlsberg there acknowledging taking ideas from Java - or explain why C# had those differences mentioned in the rest of that interview, or why Microsoft separately wrote their own Java implementation like Visual J++ if C# was just "their Java".
Checked exceptions are bad because people just catch them and rethrow RuntimeException. Proper errors as data would be much preferable.
Checked exceptions are proper errors as data. There is no difference between Result[T, E] and T throws E. The same people that just rethrow as RuntimeException would call unwrap() on Result and panic. The main problem with _Java_'s implementation of checked exceptions is that they're not fully in the type system because of Java's weak type system. That is solvable with a strong type system though, like in Scala or Swift.
> <i>people just catch them and rethrow</i><p>People don't have to. There is a lot of misinformation out there about checked exceptions, and people are responding to the misinformation.
I don't know that many languages but, having been writing lots of typescript in the last 3 years there are so many things I love about it.<p>It infers types. If I do<p><pre><code> const data = [
{ name: 'bob', age: 35, state: 'CA' },
{ name: 'jill', age: 37, state: 'MA' },
{ name: 'sam', age: 23, state: 'NY' },
];
</code></pre>
Typescript knows data is an array of { name: string, age: number, state: string }. I don't have to tell it.<p>Further, if I use any field, example<p><pre><code> const avg = data.reduce((acc, { age }) => acc + age, 0) / data.length;
</code></pre>
It knows that `age` is a number. If I go change data and add an age that is not a number it will complain immediately. I didn't have to first define a type for data, it inferred it in a helpful way.<p>Further, if I add `as const` at the end of data, then it will know 'state' can only be one of `CA`, `MA`, `NY` and complain if I try to check it against any other value. Maybe in this case 'state' was a bad choice of example but there are plenty of cases where this has been super useful both for type safety and for code completion.<p>There's insane levels of depth you can build with this.<p>Another simple example<p><pre><code> const kColors = {
red: '#FF0000',
green: '#00FF00',
blue: '#0000FF',
} as const;
function keysOf<T extends string>(obj: { [k in T]?: unknown }): readonly T[] {
return Object.keys(obj) as unknown[] as T[];
}
type Color = keyof typeof kColors;
const kAllColors = keysOf(kColors);
</code></pre>
Above, Color is effectively an enum of only 'red', 'green', 'blue'. I can use it in any function and it will complain if I don't pass something provably 'red', 'green', or 'blue'. kAllColors is something I can iterate over all colors. And I can safely index `kColors` only by a Color<p>In most other languages I've used I'd have to first declare a separate enum for the type, then associate each of the "keys" with a value. Then separately make an array of enum values by hand for iteration, easy to get out of sync with the enum declaration.
What you are describing is structural types. It is indeed a mystery that these are so under used, especially as they are a cornerstone of type theory. Structural types are so useful that they creep into most languages in some way. Even in Java, the Kingdom of the Nouns, where the rulers refused to merge a pair class, functions essentially take tuple arguments and these tuples don't have to be named and defined. You can't return a tuple though, so there is an unfortunate asymmetry. In Haskell and OCaml, we like to describe functions in a structural way, so com.google.android.Predicate would be just "a -> Bool". You wouldn't have to convert your com.google.guava.Predicate. But even these languages lack structural records and variants and suffer for it.
By now I'm also convinced that structural typing is a better default. Nominal types are still useful to assign properties that are hard or impossible to encode with structure alone (e.g. string that is a valid email address) . But I haven't encountered any other examples yet, where I'm missing nominal types.
Type inference is part of every modern language. Structural typing not so much, though.<p>Java has it through a compiler extension (<a href="https://github.com/manifold-systems/manifold/tree/master/manifold-deps-parent/manifold-ext#structural-interfaces-via-structural" rel="nofollow">https://github.com/manifold-systems/manifold/tree/master/man...</a>) but I don't know many other languages that support this feature.<p>As much as I dislike the entire Javascript runtime environment, I find TypeScript to be the best typing system out there for any imperative language.
Inferred types are really great, but I feel they do not scale. Inside a method/function? Generally fine, but the signature, including the return type, had better be explicit.<p>Also, I think there was some performance issue with too much inference? Could be wrong, could also be fixed.
This. As soon as you need to use the type in another function (e.g. function parameter), you'll discover that it's better to just write it out.
They do scale, but explicit types have two bonuses in my eyes:<p>1. can be read without a compiler, useful when reading PRs<p>2. They make the compiler work less, it's easier to check than infer
Not surprisingly, C# worlds the same way with the only exception that you have to declare the variables as “var” but they are still strongly typed
Even though that works reasonably well, you may still want to explicitly define your types/interfaces. In this example, if I do need to hardcode the data instead of fetching it somewhere, I would define the interface with "state" being a union of values, because there is nothing that stops you from using `state: 'ABC'` which would be hard to discover.
Lots of languages can infer types. And your last example with the colors is just a dictionary.
Most languages have poor support for structural types though. If you try and join two records together (like a SQL join), what will your favourite language infer then?
dictionaries generally aren't guaranteed to contain an entry for every possible value of the key type. while you could implement the colors example with a dictionary, ideally you'd want the type system to assure that given a Color, there will be a string associated with it
It's not a dictionary (type-wise). "as const" is the magic ingredient.
We need Anders to make one final language.<p>A <i>MINIMAL</i> memory safe language. The less it has the better.<p>Rust without the crazy town complexity.<p>The distilled wisdom from C# and Delphi and TypeScript.<p>A programming language that has less instead of more.
On the .Net VM you’re describing F#, mostly by virtue of being based on OCaml.<p>Contrasted with TypeScript and C#, F# is smaller, more expressive, stricter, with mature pattern matching and type resolution baked in from the ground up. F# was years ahead of the major languages on what are increasingly looking like ‘the basics’ around ADTs and immutability in modern distributed computing. OCaml and F# capture the linguistic high points of VB, Delphi, and C# with a broad spectrum of OOP(-lite) approaches, and have led those languages by decades on functional constructs that result in meaningfully tighter code. With the benefit of hindsight some approaches clearly map better to cloud computing and system verification.<p>F# also sits parallel to lots of living C#, objectively we see ‘less is more’. Less code per line, fewer lines per solution, terser and more LLM-efficient language. Error rates and refactoring costs are also meaningfully better IME, but harder to quantify in general terms.
I want something that will bring productivity of Delphi to Web. May be I am old now, but I could have built applications in a weekend in Access or Visual Basic that will take weeks now in latest web stack.
ASP.Net Web Forms still exists, though it is deprecated.
Right? I was hoping webassembly would bring back some proper gui tools like this to avoid the whole JS/DOM but no luck so far.
OutSystems, but it isn't cheap.
Hardly, even Turbo Pascal 7 for MS-DOS is more advanced than Go's type system.
C# is way to go then
> Rust without the crazy town complexity.<p>To be clear, the language has a GC then?
You don't have to use all the features of C#. I make my living at it and don't touch a lot of them. The issue with C# is culture. They went full in on blog driven development so there's way too many people who will shave the C# yak and yell this is the way to do things this week.
>We need Anders to make one final language.<p>I do feel like there is a gap for a modern compiled, functional and garbage collected language.<p>Go isn't it because it lacks the functional constructs.<p>C# and Java aren't it because they depend on a VM.<p>Rust isn't it because of its difficult memory management.<p>Swift isn't it because it is so tied to Apple and their platforms.
C#, with default tooling, can compile without needing a VM, for windows, macOS, linux and some other platforms.
What you are looking for is called F#. You get native interop with C# and access to all .NET/C# libraries as a bonus. We use it as a daily driver for a complex B2B2C cloud platform.
Does it not run in a VM?
You can embed the framework into the application so it is a single distributable.
Yes you are right, it does not properly support NativeAOT yet.<p>But it isn't a need for most use cases, unless you want to do mobile development and meet app store policies. But even then, mature F# frameworks like Fable transpile your F# code to React & Cie.
It can be compiled, but that’s not the use case it was originally designed around, so it’s not quite as first class an experience as with Go or Rust.
That's the problem though. People want one language to be The One (tm) and that's just not possible. Your The One (tm) isn't mine.
C# doesn't depend on a VM these days when it is AOT compiled. Same for Java, though C# is rather more user friendly in how it goes about it.
There are plenty of languages in that niche you could be using. OCaml, Haskell, F#...
Roc might be that language one day. Not yet because it's pre-0.1.
Kotlin has a LLVM backend, among others.
Oberon 07?
The minimal memory-safe language is Go. Turns out it's too minimal for most.
What about Lua? The language is very minimal, memory safe, and has Pascal-like syntax just like Delphi.
What would you take out of C# etc?
All non-generic container classes and nullable reference types.
(not OP) I would take out mostly historic stuff, that is in there for backwards compat, that has been superseeded. But this could be achieved using linters.
Yeah exactly.
Sounds like golang to me
Without the features I identified,yes, you’re right!
Considering they used Go for the native compiler he might actually agree with you.
Wasn’t he fired by MS?
If you feel that TypeScript, or hell even JavaScript, is becoming more alike C#, it's actually deliberately done by Microsoft in benefiting their ecosystem. In this interview they mentioned they had internal demands to convert/transpile C# into JavaScript or TypeScript. So by making these target languages more like C#, it directly benefits their need. But I don't think this should be the driving force in designing ECMAScript. When they are pushing a language feature, they have an unspoken internal goal, and every choice they make is to make JS/TS look more like C#, and they are more likely to dismiss proposals that preventing them from deliverying that goal. There's likely a bit of conflict of interest there.
As a long term observer: definitely not a goal. But you have to be clear here: JavaScript and C# both are OO languages, both are having origins stories in Java/C++, both are facing the same niche (system development), same challenges (processor counts, ...) and so on. And then, you put teams on it which look left and right when they face a problem and then you wonder that they reuse what they like?<p>C# language team is also really good. They did not do a lot of mistakes in the 25+ years. They are a very valid source of OO and OO-hybrid concepts. It is not only TS/JS but also Java and C++ who often look to C#.<p>The story was not to transform C# code to JS but to use C# to write the code in the first place and transpile it. Not for the sake of having .NET usage but for the sake of having a good IDE.
> They did not do a lot of mistakes in the 25+ years<p>If my memory serves, .NET and WinFS were the two major forces that sunk Longhorn, and both have been given their walking papers after the reset [1].<p>.NET and C# have grown to be mature and well-engineered projects, but the road there was certainly not without bumps. It's just that a lot of the bad parts haven't spilled outside of Microsoft, thankfully.<p>[1] <a href="https://www.theregister.com/2005/05/26/dotnet_longhorn/" rel="nofollow">https://www.theregister.com/2005/05/26/dotnet_longhorn/</a>
Are we mixing the language and the runtime here? C# the language seems weirdly free of weirdness and footguns.
Nope, what sunk Longhorn was politics.<p>Windows team is a C++ kingdom, and those devs will not adopt .NET even at gun point.<p>They redid Longhorn with COM and called it WinRT, irony of ironies, WinRT applications run slower than .NET with COM reference counting all over the place.<p>Google has showed those folks what happens when everyone plays on the same team, and now it owns the mobile phone market, a managed userspace with 70% world market.
.NET was already a going concern before Longhorn even started. What sank Longhorn was the fact that writing an OS from scratch is hard and maintaining compatibility with existing OSes in the process is even harder, especially when you're adopting a completely new architecture. Longhorn would have been a microkernel running 100% on the .NET runtime, mainline Windows is a monolithic kernel written in C++. I don't know how it would have ever worked, whether .NET was "perfect" or not.
Not at all. Before the use of TypeScript exploded, they had two features brought into it from C# which were namespaces and enums (both of which are amazingly good features. For the first one, no one knew what was the right choice back then. We had almost a dozen different module systems and TypeScript had gone their way to support all of them and namespaces were their own solution to the mess (remember they were trying to solve their own problems at first, it wasn't to dominate anything). I personally used namespaces and I could have only the TypeScript compiler running and producing a single JS file for rapid development without the burden of --- then very slow --- webpack.<p>And for enums, using strings as enums was not a very efficient idea. I think JavaScript introduced Symbols for locked/hidden properties but also meant to use them as enums. It never worked either and then the sum type, union type feature of TypeScript made the whole community to keep using strings as enums. This is still a very bad idea, it is not ergonomic, it is prone to many problems, and very inefficient to compare strings instead of integers. But hey TypeScript tried to fix the problem and almost everyone rejected it. And so enum is now discontinued.<p>Rest of the changes to TypeScript came from almost any other language but C#, probably the biggest changes ever to happen to JavaScript came directly from CoffeeScript. And then I personally saw how each of these new changes --- one by one --- arrived at C#. For what I have seen firsthand by reading the TC39 proposals, each feature came from a different community and different programming languages, (think about null operators !/?, the nullish coalescing ??, the incoming pipes, fat arrows and lambdas, mixings) as JavaScript is the only language everyone has to use, and it has benefited everyone to have a language that has all the great things from all other languages.
Well, for one, benefiting Microsoft's ecosystem does not imply being detrimental to other ecosystems per se.<p>Furthermore, couldn't the convergence of TypeScript towards C# be simply a result of shared goals and values of the two languages, especially considering they have the same principal designer?
C# is inherently OOP oriented and it's type system works completely differently.
It sounds like conspiracy theory that they design TS/JS to convert from C# easier, huh.<p>The truth is that C# is probably the best designed mainstream language out there.<p>C# was known as a language with lowest amount of WTF per LoC
that's the "evil MS" perspective<p>The sequence of turbo pascal / delphi / c# / typescript which brought us LSP as a sidekick (!) IMHO has benefitted the whole industry at least as much as "transpile c# to ecma script via typescript" . no. much much much more.<p>I do not see a problem with MS also having an internal use case .<p>you know I wouldn't stop using python "because" Guido now works at MS ...
Python has an elected steering council and core team. The governance process explicitly tries to avoid conflict of interest by disallowing more than two steering council members working for the same employer. See PEP 13 [1].<p>By contrast, .NET is controlled by Microsoft (with veto over board decisions [2] and code changes [3]), integrates Microsoft's telemetry to send your data to Microsoft by default [4] and deliberately hobbles features to benefit Microsoft [5].<p>[1] <a href="https://peps.python.org/pep-0013/" rel="nofollow">https://peps.python.org/pep-0013/</a><p>[2] <a href="https://dotnetfoundation.org/about/policies/.net-foundation-bylaws" rel="nofollow">https://dotnetfoundation.org/about/policies/.net-foundation-...</a><p>[3] <a href="https://github.com/dotnet/runtime/blob/main/CONTRIBUTING.md" rel="nofollow">https://github.com/dotnet/runtime/blob/main/CONTRIBUTING.md</a><p>[4] <a href="https://github.com/dotnet/sdk/issues/6145" rel="nofollow">https://github.com/dotnet/sdk/issues/6145</a><p>[5] <a href="https://github.com/dotnet/sdk/issues/22247" rel="nofollow">https://github.com/dotnet/sdk/issues/22247</a>
Spot on.