Programming the Commodore 64 with .NET

Programming for the C64 CPU is terrible. You couldn't even attempt to port a dotnet subset.

There isn't a multiplication instruction, so you have to painstakingly reinvent all useful algorithms from the last 40 years from nearly scratch and by the time you want to implement a hash you notice you're running out of RAM.

> Many more elaborate projects exist. My favorite is the one that compiles something similar to Turbo Pascal to C64 6502

It depends on the purpose. The reference IDE is intended to produce real-world programs (it includes tools for sprites, music etc.), while high level language compilers are mostly academic, as they're not performant enough.

Imo, this is actually way more interesting.

Everybody's gotta bring Java into it.

Citing my own comment from another thread:

I've worked with .NET for over 10 years and we built our startup on top of it. Here are my thoughts: Pros:

* Stability

* Very decent standard library

* Good balance between productivity and robustness

* Great package management

* Extremely easy to upgrade, so essentially free goodies (performance) every year or so

Cons:

* Very MSFT dominated (obviously)

* Subpar tooling outside of Windows (I'm looking at you C# Dev Kit)

* C# has way to many features, it feels bloated

* Culturally, it feels like .NET devs are less "passionate" about their work

* The freaking stigma of being a .NET dev: you will never be as cool as the guys who work with Node/Python/whatever

Edit: Also I'd like to add EFCore as one of the pros of the ecosystem. Hands down the best ORM. Others don't come close.

It's a huge leap forwards from those days.

- Works on linux/macos, x86/ARM64.

- The mature frameworks (e.g. ASP.NET with razor pages) are great. Microsoft still have the same issue of pushing new and different ways of doing web things, but you do see a lot of that on the web platform in general.

- CLI workflow for compilation/build/deployment is now there and works smoothly. VS Code extensions for a bit of intellisense without requiring a full IDE (if that's the way you work).

The thing I enjoy most about modern C# is the depth/levels of progressive enhancement you can do. Let's say in the first instance, you write a proof of concept algorithm using basic concepts like List<T>, foreach, stream writing. Accessible to a beginner, safe code, but it'll churn memory (which is GC'd) and run using scalar CPU instructions.

Depending on your requirements you can then progressively enhance the memory churn, or the processing speed:

for(;;), async, LINQ, T[], ArrayPool<T>, Span<T>, NativeMemory.Alloc, Parallel.For, Vector<T>, Vector256<T>, System.Runtime.Intrinsics.

Eventually getting to a point where it's nearly the same as the best C code you could write, with no memory churn (or stop-the-world GC), and SIMD over all CPU cores for blisteringly fast performance, whilst keeping the all/most of the safety.

I use .NET at $job, and have been running arch for the last few years, without any problems. I also have two collegues using Apple silicon, also no problems there.

The official aspnet core web framework is (in my opinion) good enough that you don't need anything 3rd party.

The GUI story is not a good one though, and if I were to write a GUI program I'd reach for Avalonia (3rd party, free).

I use Rider as IDE, but there are multiple other options.

With the recent performance improvements (Span, Memory, Intrinsics, etc) it's possible to write quite performant C# these days, and with low GC pressure.

You can read an overview of what's new with the language (although missing C#14 which was released days ago) here: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/cs...

Honestly, .NET should be the default choice for any non-trivial backend or non-GUI application. I assume the legacy (outdated/inaccurate) perception of MSFT's stewardship is the only reason anyone reaches for something else.

AOT is a game changer for native binaries, but even with fw dependence, the cross platform support is excellent (we deploy to Linux servers frequently.)

The Linux story is much better now. Back end the day it was necessary to try to use Mono which wasn't fully compatible and the code had to have #if defs all over the place. That is thankfully all gone now.

Most things can be done with the dotnet cli but for editing code, realistically you will want to use an editor like vscode, Rider or Visual Studio itself. I found the LSP support in vim quite bad for C#.

It runs perfectly fine on Linux since .NET Core.

There is only one relevant web framework: ASP.NET Core. Microsoft is as bad at naming things as it has always been, so that hasn't changed. They're pretty good about not deprecating too much in the web area now, the big disruptive change was from .NET Framework to .NET Core. The Windows UI stuff seems to be a bit of a shitshow in terms of deprecations, but I've no direct experience with it.

At my daily job, our production servers are Linuxes, and we deploy our .NET code (fairly complex web app) just fine, using the same techniques you would with other technologies like CLI GitLab CI/CD, Docker, Kubernetes... Forget about GUI if you're not into it.

The web framework craze is settling down. Microsoft seems to have consolidated into two web frameworks: Blazor (improved/extended Razor Pages) and ASP.NET for MVC, and APIs. I personaly don't expect another U-turn for the coming years.

Blazor is really nice, and ready for production. The only downside I see is that Visual Studio (vanilla) struggles compared to another MSFT technologies. You don't need Visual Studio, though.

I am a full time .NET developer, experienced with both newer and older .NET versions.

They are confusingly named, but this is the gist: - .NET Framework is the older version that is tied to Windows. - .NET is the newer version that is cross platform, and was renamed from .NET Core.

Linux support is pretty good on .NET. I don't have as much experience with this personally since most of my company is still using .NET Framework, but I was able to get a simple .NET app running on Linux without any hassle.

The main web frameworks I am aware of are Blazor and MVC. Blazor behaves more like a single-page application (without needing JavaScript!) and abstracts away most of the headache of making dynamic web pages, but generally doesn't scale as well from what I have seen. MVC is a little more traditional but you need to write some JavaScript for interactivity.

I'm not fully sure what you mean by GUI heavy. Everything I am aware of can be accomplished with the CLI tooling.

I've been running .NET web apps on Linux since 2018 (early .NET Core versions)

ASP.NET is stable and really good web framework