Dude says LTS dot net releases should have another 3 years minimum of security updates. I agree with this, can down voters please share your reasons for down voting?

I find articles on the onion to be funny in some way. This was just naked approval of the status quo.

I think "describing it as if it were normal" only helps the people who support this arrangement because it gets normalized. That's where the accusation of conservatism came from, that and the way they tried to shut me down with insults.

Edit: given that there are likely to be a lot of people that agree with this argument unironically, doesn't it seem irresponsible to play some game where you pretend like you support it? Without ever coming out against it at the end?

Really, it's just naked approval, with any disapproval left as an exercise to be performed by the reader.

Ii is the real state of the world, but I don't see any disapproval in the text.

Who would build any sort of factory if they did not know that many people would be available to take the jobs at low-pay rates

Much of the hunger lirerarure talks about how it is important to assure that people are well fed so that they can be more productive. That is nonsense

No one works harder than hungry people.

[...]well-nourished people are far less willing to do that work

For those of us at rhe high end of the social ladder, ending hunger globally would be a disaster.

I guess the irony is lost on me. Nothing here indicates that it's wrong or should change. Also, you're a huge asshole.

Edit: in fact I know people (conservatives) who are totally fine with this arrangement. They are huge assholes too, huh isn't that weird.

This is just a bad thing to say to someone. That's all.

It's these damn activist judges, we need to get a few.

It's fucked that the author appears to support such an arrangement...

No, the text is pretty fucked, too

Ok, I'm in for $2 /month too, thanks for setting the standard!

C# is a great language, I don't know much about game dev but I know unity and godot game engines have good support for c#. You can target Windows/Linux/Mac on all the common architectures. All the build tools are available on the command line if that's your thing.

This is the right idea imo. Tax wealth, not income.

Problem is, programmers don't want AI. We want better tools that address the issues of complexity and abstract requirements management.

I very much disagree with this, Null Reference Exceptions have been a huge problem in c#. Nullable reference types are a partial fix, but the question of "how do I 'return' an error from a statically typed method" is not answered there.

Thank you, I'd love to hear back from you.

Check the edit on the post, I thought I had linked to the GitHub page but I guess the image overrides that.

Link: https://github.com/Andy3432344/SafeResults

Check the edit on the post, I thought I had linked to the GitHub page but I guess the image overrides that.

Link: https://github.com/Andy3432344/SafeResults

The operator being applied to the ResultObject will always resolve to the Generic type that was specified as 'T in IResult<T>. If the function is not successful the resolved value will be whatever value was supplied to the ResultObject constructor, the opt.None property will true and the opt.Some property will be false.

The example is simplified, but I dislike returning null in my own code. The function will always execute, left or right doesn't matter it's mapped across in the ResultObject class.

The function must return an IResult<T>, the ResultObject analyzes the IResult<T> checking for IFail or IOk. If it's IOk the value of type T is retrieved from the Value property of the IOk<T> object and returned, the Some property defaults to true. If the IResult<T> is an IFail, Some is set to false, it copies the message from the IFail object into the ResultObject, and returns the value the was supplied to its constructor.

I'm just sharing something I find useful, and I hope I can make it useful for others as well. Thanks for the questions.

Here's a real world side project example of how I handle this situation:

 public IResult<T> GetResourceValue<T>(string path)
    {
        string err = $"{typeof(T).FullName} is not available from this Resource ({nameof(FileSystemResource)})";

        switch (typeof(T))
        {
            case Type t when t == typeof(DriveInfo):
                return (IResult<T>)new Ok<DriveInfo>(BackingValue);
            case Type t when t == typeof(DirectoryInfo):
                err = $"Directory path invalid: {path}";
                var dir = new DirectoryInfo(path);

                if (dir.Exists)
                    return (IResult<T>)new Ok<DirectoryInfo>(dir);
                break;
            case Type t when t == typeof(FileInfo):
                err = $"File path invalid: {path}";
                var file = new FileInfo(path);

                if (file.Exists)
                    return (IResult<T>)new Ok<FileInfo>(file);
                break;
        }
        return new Error<T>(err);
    }

You said elsewhere that it feels like you're doing something wrong if you have to check for every type just to use a Generic. I think you're right in thinking along those lines. There should be a minimal number of types to check, and Ideally limited via a type constraint.

Here's example that includes a constraint:

    public IResult<T> GetValue<T>() where T : struct =>
        typeof(T) switch
        {
            Type t when t == typeof(int) && value <= int.MaxValue =>
             (IResult<T>)new Ok<int>((int)value),
            Type t when t == typeof(uint) && value <= uint.MaxValue && value >= uint.MinValue =>
             (IResult<T>)new Ok<uint>((uint)value),
            Type t when t == typeof(byte) && value <= byte.MaxValue && value >= byte.MinValue =>
             (IResult<T>)new Ok<byte>((byte)value),
            Type t when t == typeof(sbyte) && value <= (int)sbyte.MaxValue =>
             (IResult<T>)new Ok<sbyte>((sbyte)value),
            Type t when t == typeof(short) && value <= (int)short.MaxValue =>
             (IResult<T>)new Ok<short>((short)value),
            Type t when t == typeof(ushort) && value <= ushort.MaxValue =>
             (IResult<T>)new Ok<ushort>((ushort)value),
            Type t when t == typeof(long) && value <= long.MaxValue =>
             (IResult<T>)new Ok<long>((long)value),
            Type t when t == typeof(ulong) => (IResult<T>)new Ok<int>((int)value),
            _ => new IntegerError<T>()
        };