• MagicShel@programming.dev
    link
    fedilink
    arrow-up
    5
    ·
    8 months ago

    Let’s say you currently have an overloaded “god method” that is used for twenty different things. The proper thing to do would be to create twenty different interfaces that each do one specific thing and then call the syscall behind the scenes. That allows you to update and modernize your apps, allows for better testing of specific use cases, etc.

    The original exposed syscall is deprecated and then eventually you force all the reliant code to adopt the proper new interface. The original overloaded code is still there, but locked up in a black box where no one has to worry about it.

    • LufyCZ@lemmy.world
      link
      fedilink
      arrow-up
      4
      ·
      8 months ago

      Yeah, but people don’t like change, and I’d expect low level engineers to like it even less.

      And looking at Linux, that shit still supports ancient hardware, being able to actually get rid of old code (that now has to be maintained alongside the new code) is gonna be a PITA.

    • QuadriLiteral@programming.dev
      link
      fedilink
      English
      arrow-up
      2
      ·
      8 months ago

      And then those methods grow and grow, or stop making sense, or start meaning something else, and you would have to go through the same abstract-deprecate-remove again. Rinse and repeat and if you do this regularly enough you have web development where you get your feet swept from under you every couple of years.

      It’s a bit of a pick your poison situation, for me the backwards compatibility path is the right call here though.

      • MagicShel@programming.dev
        link
        fedilink
        arrow-up
        2
        ·
        8 months ago

        I know where you’re coming from here. All I can say is there is something else wrong in this case and this is how it’s being expressed. I’ve seen it several times myself and sometimes no amount of good coding can fix bad architecture.

        But I will say that if the twenty use cases all grow to the point of needing their own abstraction, I think you’d be damn glad there was at least a point of separation instead of having to maintain all possible permutations in a single method signature.