• 10 Posts
  • 552 Comments
Joined 1 year ago
Cake day: July 2nd, 2023
  • JakenVeina@lemm.eetoProgrammer Humor@programming.dev•C++ try not to add footguns challenge (impossible)English
    9·
    5 days ago

    It’s the capability of a program to “reflect” upon itself, I.E. to inspect and understand its own code.

    As an example, In C# you can write a class…

    public class MyClass
{
    public void MyMethod()
    {
        ...
    }
}

    …and you can create an instance of it, and use it, like this…

    var myClass = new MyClass();
myClass.MyMethod();

    Simple enough, nothing we haven’t all seen before.

    But you can do the same thing with reflection, as such…

    var type = System.Reflection.Assembly.GetExecutingAssembly()
    .GetType("MyClass");

var constructor = type.GetConstructor(Array.Empty<Type>());

var instance = constructor.Invoke(Array.Empty<Object>());

var method = type.GetMethod("MyMethod");

var delegate = method.CreateDelegate(typeof(Action), instance);

delegate.DynamicInvoke(Array.Empty<object>());

    Obnoxious and verbose and tossing basically all type safety out the window, but it does enable some pretty crazy interesting things. Like self-discovery and dynamic loading of plugins, or self-configuration of apps. Also often useful when messing with generics. I could dig up some practical use-cases, if you’re curious.

  • JakenVeina@lemm.eetoLearn Programming@programming.dev•Is it better to check if a file exists before trying to load it, or to try to load it, and catch the error and move on?English
    71·
    27 days ago

    General wisdom is that if you can perform some kind of pre-validation action to prevent an exception from occurring, you should do that, rather than expect the exception and handle it, as part of “normal” flow control.

    However.

    Some types of exceptions, especially when related to itneracting with shared/external systems, cannot be conpletely avoided. Checking for the existence of a file is the textbook example of this. No matter how much you check of the existence of the file, it could technically be deleted or exclusively locked by another process before you get a chance to actually open it.

    For all intents and purposes, that’s not really likely to happen, so by all means, check for the file, to keep your code sensible, but make sure you have a general strategy for exception handling in place as well.

  • JakenVeina@lemm.eetoProgramming@programming.dev•What is your preferred API error response and why?English
    1·
    29 days ago

    #4 for me.

    Proper HTTP Status code for semantic identification. Duplicating that in the response body would be silly.

    User-friendly “message” value for the lazy, who just wanna toss that up to the user. Also, ideally, this would be what a dev looks at in logs for troubelshooting.

    Tightly-controlled unqiue identifier “code” for the error, allowing consumers to build their own contextual error handling or reporting on top of this system. Also, allows for more-detailed types of errors to be identified and given specific handling and recovery logic, beyond just the status code. Like, sure, there’s probably not gonna be multiple sub-types of 403 error, but there may be a bunch of different useful sub-types for a 400 on a form submission.

  • JakenVeina@lemm.eetoMemes@lemmy.ml•I hate these iconsEnglish
    211·
    29 days ago

    Anyone else this there’s actually nothing at all wrong with the “New” row of icons? Except for the triangle one, which is terrible in its “Original” version as well, as it indicates absolutely nothing about its app (I believe it’s Google Drive, right?). All the rest are clearly distinguishable, and have relevance to what the app does.