This is the very first thing I do when picking up a new tech - language, framework, library, tool. After initial familiarization with the basics - Wikipedia/Readme-Intro, I would google "Why does X sucks", and try to avoid becoming overly enamored with it too quickly, and strive to maintain a level-headed perspective.

Ok. For anyone struggling with the second, the answers should be:

Lack of libraries.

Lack of good tools.

My favourite languages are C# and C++, and sometimes I interview developers to work with them. Saying these languages are lacking libraries or good tools is unreasonable.

True, but it's trivial to come up with things to dislike in C++ :-)

Great point on C++, but it’s harder for C#. The language and ecosystem are IMO pretty good.

I only hate that Microsoft stopped shipping modern .NET runtime with Windows. A few annoying things though, like the recent push towards AOT compilation (IMO strictly worse that JIT), and the lack of a good first-party cross platform GUI frameworks (for example Microsoft could compile d2d1.dll with DXVK, reimplement dwrite.dll API on top of FreeType / HarfBuzz, and copy-paste UWP).

What I dislike about C# is how much effort is needed to get a minimal environment. Rust and Python make simple code compilation quick and easy.

Let's assume I want to use a C# script .csx file. The CSX filetype seems to be Microsoft's flavor of attempting to "make it simple". I write a hello world. Now what do I do with the .csx?

I have no idea how to compile that with modern dot net.

It appears csi.exe would have been the answer, but now Roslyn seems to be the current best practice. No idea what to do though

I'm not sure where you are coming from in terms of difficulty of setting it up, it's just

    - sudo apt install dotnet-sdk-8.0 / brew install dotnet-sdk
    - dotnet new console -o {folder} --aot
    - dotnet run -c Release
    - optionally dotnet publish -o .

If you want to use it as a scripting language, you do `dotnet tool install -g dotnet-script` and use it normally[0]. Keep in mind that C# is not designed for this, but it will work (at the cost of first uncached script launch costing extra - it is a compiled language after all, but that's a niche scenario anyway).

[0]: https://github.com/dotnet-script/dotnet-script?tab=readme-ov...

Thanks, I will look into the github repo. Although I think it's a bit confusing, since the steps you describe above lead to a requirement for the .net 8 runtime which leads to the following licensing information. It's not clear how to proceed with C# development as an open source language. I thought maybe it could be done by cloning Roslyn (MIT license) from github.

Do I need to accept the below licenses to develop a C# app? I'm not asking you specifically, just that I don't care to try and understand if I can even use the language without accepting any of the below, (anything not MIT or Apache)

License information for .NET on Windows

The Windows distribution of .NET contains files that are provided under multiple licenses. This information is provided to help you understand the license terms that apply to your use. By using any or all of these files you agree to their associated license terms.

The following binaries are licensed with the Windows SDK License:

api-ms-. (used by .NET runtime, .NET 6 and earlier) ucrtbase.dll (used by .NET runtime, .NET 6 and earlier) D3DCompiler_47_cor3.dll (used by WPF)

The following binaries are licensed with the .NET Library License

Microsoft.DiaSymReader.Native.{x86|amd64|arm|arm64}.dll (used by .NET runtime and SDK) PresentationNative_cor3.dll (used by WPF) wpfgfx_cor3.dll (used by WPF) The following binaries are licensed with the Microsoft Visual C++ Runtime Software License:

vcruntime140_cor3.dll (used by WPF)

All other binaries and files are licensed with the MIT license

This document is provided for informative purposes only, and is not itself a license.

I'm still as confused. Where do people even find those? Are you sure you are not intentionally misinterpreting information? Because it does seem so.

In any case: https://github.com/dotnet/dotnet/blob/main/LICENSE.TXT

I followed your instructions, ran dotnet build, and attempted to run the debug build .exe.

I got a message "You must install .NET to run this application."

So I followed the link[0] given as part of the CLI output which led to the .Net Runtime installer. Inside the installer it stated "By clicking install, you must agree to the following terms" and a link[1] was part of the terms I must agree to.

[0]https://aka.ms/dotnet-core-applaunch?missing_runtime=true&ar...

[1]https://github.com/dotnet/core/blob/main/license-information...

I would prefer not to accept non-MIT terms...

No need for personal attacks. I still stand by my opinion. Without a project template, you would be in the dark to set up a project. .sln files and .proj files are arcane and I might be dumb for not being able to create these by hand but I think most people would agree it is arcane hidden XML and a pain.

I need to reorganize the generated project template because it's not actually up to common standards of what a project directory should look like. As a newbie I would never know that I need to find David Fowler's gist[0] to have a project that makes sense.

Good luck trying to change the default .bin folder without aid from a third party's script or Visual Studio.

It's not obvious how to create a project settings JSON file. There are entire paid video workshops for this task alone. This kind of code should be pre-generated in the template.

This is all stuff that should be handled before a user even touches the environment.

[0]https://gist.github.com/davidfowl/ed7564297c61fe9ab814

It seems you're interested in proving your world view rather than finding (easily available) solutions to your problems (the whole argument was pure hypocrisy - you're asking about native dependencies that ship with OS, that isn't MIT, instead of using e.g. Linux, if that's what you care about). You did not even follow the initial easy steps to set up a project or did not look up basic CLI commands like dotnet new or dotnet sln to easily manage whatever you're working with (it's easier than Go and similar to Rust's cargo).

I have never seen a programmer struggle this much, failing to follow basic list of steps and ending up at the strange links from google, so my point in the previous reply continues to be relevant. Hell, an acquaintance of mine managed to get NativeAOT compilation working on the second try despite exotic NixOS setup and having zero experience with .NET beforehand.

And mind you, my first job was first level of customer support, so there were a fair share of users that misread the messages, and this case is like one of those bad ones. And, you know, the users who have a problem usually at least make an attempt to understand, as they are invested in solving it. But because you are invested in the opposite, no amount of explanation will help.

Note to readers: do not follow the structure at the link, it's outdated and refers to personal template preferred by David Fowler, you don't need all of that and it was also created during the days of .NET Core 1.

There are two main "project manifest"-like files that .NET uses: .csproj (or .fsproj and similar) to declare projects, and .sln to group multiple projects together. Those are managed with `dotnet new {templateName}` and `dotnet new sln` then `dotnet sln add/remove {path/to/project}`. Everything else is optional.