In my experience the strengths of Go are mostly - Deployability via single-file static binaries - Simple syntax that anyone can learn (no exceptions, no classes or inheritance) - Wicked fast compile times

And the strengths of C# are - Powerful language with null-safety and lots of syntax sugar - Runtime-level coroutines so you don't need `async/await` everywhere

G# seems like it has the _worst_ of both worlds, not the best. It's fun to write compilers, and good on them for doing it, but no thank you for real use

20 years ago there was some momentum behind Visual Basic .Net; but the language was so similar to C# that it just wasn't worth using. There was a joke that .Net was a "skinnable language."

BTW, there's a whole nitpicky/semantic argument that C# isn't null safe because of the null forgiving operator. That will probably come into play with G# if the null forgiving operator can be used from C# to pass null into G# code that doesn't expect it.

Calling a language with `let` instead of `const` and async/await and iterators and classes "Go" is plain just incorrect. This G# is more similar to TypeScript than Go.

The ONE feature that C# really needs is payload enums with `match` instead of C#'s current pattern matching with `switch` anyways, and Rust is more similar to Go anyways so why not copy from Rust instead? I'm honestly baffled.

- what is the thought process that goes into making a programming language

- what is this field of study or discipline called?

- why do we have so many programming languages? what purpose do they intend to solve and how do we know what purpose a programming language was made for?

- for example, why was swift made if objective c exists and why was objective c made if c++ exists?

``` G# brings Go-, Kotlin-, and Swift-style ergonomics — packages, func, data class, nullable handling with if let, structured concurrency with scope — to the .NET runtime. Source compiles directly to managed assemblies. ```

This is a decent description - but as someone also building a language in a similar space - who isn't super familiar with the .NET runtime... My first question is... Why not C#?

I'm by no means a C# expert, but I thought most of this was supposed to be in C#. C# is not terribly un-ergonomic, and Go is simple, but not really ergonomic except for Goroutines...

`packages` and `func` being the first two selling points is alarming. Sure, people probably prefer `fn foo() -> Dog` over `Dog foo()`. No one's picking a language for that. C# has namespaces... C# has `record` and `record struct`. C# has not-ideal nil handling, but it still has it. I'm not convinced `if let` is better enough to be a selling point - a lot of people don't like that!

Your main selling point seems like `scope` and your concurrency model vs C#, but C#'s is not exactly terrible...

Rich Hickey has a joke about semi-colons in language design, and your main pitch seems to sell yourself short.

Btw, I think your GitHub page does your language a lot better justice.

Maybe .NET AOT will get there one day..

why do people still accept CSP? It is simple to do some things in it, bit please just give me concurrentML with "simple" channels for that kind of work , and proper channels for any kind of hard stuff. I have had to write things in go that took me days to get straight that would have been 20 trivial lines in any concurrentML implementation.

I feel like we've done full circle. Languages are back to being (mostly) procedural. I'm not sure I like it, but it seems that this is what people prefer.

Personally, I'd rather see something like dependant types on a dotnet language. An addition, not just a simplification.

What a great era.

Means "for 1 to 4". Kill me now.

Have to ask what is the point of .NET is it even needed being the navel gazing MS fraternity?