HI version is available. Content is displayed in original English for accuracy.
Advertisement
Advertisement
⚡ Community Insights
Discussion Sentiment
93% Positive
Analyzed from 959 words in the discussion.
Trending Topics
#language#net#languages#syntax#null#seems#https#lot#runtime#similar
Discussion (21 Comments)Read Original on HackerNews
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.
IronPython[0] and IronRuby[1] would like a word... Largely so they could be remembered.
0 - https://en.wikipedia.org/wiki/IronPython
1 - https://en.wikipedia.org/wiki/IronRuby
I remember the MS documentation had sample code in all the variants of .NET languages they created (C#, F#, VB.NET), and of course there were decompilers that let you choose which one to target, with many other translation tools available between them.
Not that either of these things is disqualifying but AI really has make it difficult to know how established a project actually is.
Maybe .NET AOT will get there one day..
It was nice. Feel free to take a look
https://github.com/OctopusDeploy/OtelImporter
``` 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.
I didn't see semicolons, but I saw plenty of {} braces, and I can't explain why they're needed.
https://github.com/Syzygies/Compare
"I'm already quite sure how I will die: I'll read another article on Hacker News about a new programming language where I see nothing new, and I'll read that they included {}; to make C programmers comfortable. I'll have a massive stroke."
"Curly braces" (a.k.a. "{}") make lexicographical scope simpler to manage for lexers and parsers. Alternate grammars increase compiler complexity, excluding trivial token replacement.
As for semicolons, they are only a linguistic requirement for supporting multiple executable statements on the same source-code line.
C# grew all those features over time. It had to leave syntax to support old patterns to preserve backwards compatibility. Thus, the syntax has grown a bit noisy over time to support all those features. This is reboot keeping the newer ergonomics and streamlining the syntax.
I probably wouldn’t adopt it for existing projects or use .Net for any future project, but it looks really nice for what it is.
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.
Is this an actual shift, or is this just what happens when LLMs make it possible for anyone to build a language quickly?
This one feels less like someone thought carefully about what semantics they wanted to have and more like someone without a lot of familiarity with the design space of programming languages decided to build one that had all their favorite features from the languages that they already know:
> 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.
Nothing wrong with that at all, I love to see the increased interest in language design, but I wouldn't read a shift in preferences into this wave of PLs. It's a shift in who is writing PLs, not a shift in preferences.