RonSijm

It's been way too long since we had some good Real Time Strategy games.

Hope Stormgate is gonna be good

The microsoft way is probably still WPF, yea. Though there are some articles every once in a while asking "Is WPF dead?" etc

A good alternative is Avalonia, syntax wise pretty close to WPF, but more community driven and cross-platform

I use it to backup my save games. Not sure if that's conventional.

For example, I'd MKLink %appdata%/Local/Pal/Save/ to a folder in my save repo, and commit that every once in a while.

The current answers using a Func or an Action are correctish, but with that approach you will have logging cross-cutting hard-wired into all your classes before invoking the methods.

If you want true AOP or decorators, you probably want to use Type Interceptors. And Castle DynamicProxy. See: https://autofac.readthedocs.io/en/latest/advanced/interceptors.html https://blog.zhaytam.com/2020/08/18/aspnetcore-dynamic-proxies-for-aop/

A dynamic proxy will give you a method like this:

public void Intercept(IInvocation invocation)
{
  _output.Write("Calling method {0} with parameters {1}... ",
    invocation.Method.Name,
    string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()).ToArray()));

  invocation.Proceed();

  _output.WriteLine("Done: result was {0}.", invocation.ReturnValue);
}

Intercept is called before invoking a method, you can do stuff before the method starts, then you call invocation.Proceed(); - that invokes the method, and then you can log the result.

Note that your class methods either need to be virtual, or it needs to have an interface, I'd suggest an interface.

This way you can wire the logging part in through dependency injection in your container, and your classes itself don't contain logging cross-cutting logic

Logging wise, I'm not sure how familiar you are with dotnet, as you're saying you're just starting, I'd suggest inside your classes you stick with Microsoft.Extensions.Logging.Abstractions - so your classes - lets say a class MyService - would be

public class MyService(Microsoft.Extensions.Logging.ILogger<MyService> logger) { }

Then I'd suggest Serilog to use as concrete logger. You'd wire that in with:

     var configuration = new ConfigurationBuilder()
        .SetBasePath(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!)
        .AddJsonFile("appsettings.json")
        .Build();

    services.AddLogging(loggingBuilder =>
    {
        var logger = new LoggerConfiguration()
            .ReadFrom.Configuration(configuration)
            .CreateLogger();

        loggingBuilder.AddSerilog(logger, dispose: true);
    });

Sirilog is a very extendable framework that comes with 100s of different Sinks so you can very easily wire in a different output target, or wire in different enrichers without modifying any of your existing code

If you have a C# project that I can help with, as you mentioned, would be cool. I don't have that much experience with Rust, besides getting the Lemmy backend to compile.

I have experience working on the Lemmy APIs; I was trying to make my own front-end lol: https://blamm.it (Because mlmym requires a running Go Backend Proxy, to proxy requests between the Front-end -> Go Backend -> Lemmy Backend) - (which could easily be running maliciously, since you can't verify the hosted Go Backend isn't modified to log requests or something) - (And it's slow)

Hosting wise I have loads of experience with AWS... though not sure where you're hosting

The forks could just change their name, so they're more easily found. For example mRemote got pretty much abandoned, so mRemoteNG got created.

Or people give forks better names. For example, I've forked some dotnet6 project, and called the fork {project}-dotnet8 - then when people look thought the fork list on github, it's not 20 forks all with the same name

It's not even the "quality of the project" like suggested in this thread. It's the quality of the commit messages (meta-data, documentation)

That's like someone who paints for a hobby, and shows their paints off on the internet, and people would post stuff like "Well cool painting, but you didn't really explain what kind of paint you've used, who your inspirations were" etc etc

When I'm building Open Source stuff as a hobby for things that are useful to me, and also dump them on Github - because it's a good backup system - I don't really care whether people might go through the commit history as means to figure out how I've build it

Well "Device based" is even more broad, haha. If you're also including iOS and Android.

Then you'd be looking at a cross-platform developing lanuage, like Flutter, React Native, Xamarin etc.

So the question is, what is the goal for your GUI? Is this a personal project where you just want to have a GUI for a specific system? (Windows / iOS system) - Or something published that you want people to be able to use on all devices?

It's been a while since I did something like this, but I think you can do it though Google Play Install Referrer API.

I assume you'd have a "Download App" button on the landing page, then you'd append a userId to the download url.

I think this explains it: https://developers.google.com/analytics/devguides/collection/android/v4/campaigns

Now as for the “Java bad”, I’m kind of guilty of it too. I very much dislike how academia is obsessed with UML diagrams.

I'm kind of guilty of that too - in mindset - I just don't go around and shitpost about Java.

My dislike for Java also came from academia, since I had to use it in school. Though my main problem was just the general tool chain of Java. Like we had to use Eclipse or NetBeans. And then we had to write stuff in "JavaBeans" When instead of a normal "Person" class, you'd have to have a "PersonBean" and everything was so weird. And all the packages and references would constantly break or be missing, both in the project and even in the IDE itself...

After moving to C# and using Visual Studio, NetBeans just feels like you're trying to build a house with a rock instead of hammer, on an already crooked foundation.

Though that was a long time ago. I assume things have improved. But I never really had any reason to go back to Java

When you said "GUI Programming" What kind of GUI are you talking about? A web-based GUI or a desktop-based GUI?

Web-based the go to framework is generally React or Angular.

If you're talking about Desktop based, you probably want to stick with the language that you're also building the logic in. Like you could use another language like C# and write a front-end in Avalonia, but then you'd have to interlop from C# to Python.

You could also pick a language that's supported by Electron, then you'd basically be doing Web-Development but for desktop.

Well Lemmy is Rust - Plus Lemmy is already an alternative for Reddit, so all the "normies" are still on Reddit - So Lemmy itself is already a bit of a niche sample size.

Rust developers are already known (/memed) to be elitist about Rust - and "Java is Bad" is also just the general consensus among developers, especially ones using more niche languages