• Rikudou_Sage
    link
    fedilink
    English
    141 year ago

    I remember the old times where every class in my codebase extended Database and I thought how clever that was and how cool inheritance is.

    • @u_tamtam@programming.dev
      link
      fedilink
      English
      4
      edit-2
      1 year ago

      So, what would you do instead in this case, use a DI framework to pass the Database capability around?

      (Edit: I do realize the answer is likely to be language dependent)

      • @AdamBomb
        link
        English
        71 year ago

        That would be a good solution most of the time, yes

        • @u_tamtam@programming.dev
          link
          fedilink
          English
          11 year ago

          Yeah, I find DI really scary. It practically shifts the complexity elsewhere, out of the programming language and program, and into configuration and classloading magic, that you may eventually discover at runtime.

          I think I would prefer languages to embark proper abstractions for that. Scala has implicits which are not as refined as some DI frameworks I’m sure, but do the job in practice. In general, there should be a way for programs to delineate portions of code that expose/depend on certain capabilities (use a database, or more generally run asynchronous, frees its own memory, is a pure calculation), and this is an avenue being researched in capabilities-based languages.

          • @AdamBomb
            link
            English
            21 year ago

            I hear your concerns about DI frameworks and I agree it would be preferable if their config could somehow be validated at compile time instead of runtime. That being said, in my experience, runtime issues are fairly rare. Some DI frameworks even provide a simple method you can call at runtime to validate config at startup. Furthermore, you can use the DI pattern without a framework— design your classes accordingly, then create and inject the dependencies yourself instead. The point is to program against abstractions to make your code more testable, and while a framework can automate away some of the bookkeeping, you can dispense with using a framework for any of a number of valid reasons.

    • @Olap@lemmy.world
      link
      fedilink
      English
      21 year ago

      It’s still cool. Ain’t nothing wrong with what ain’t broke. Imagine programming without inheritance in many languages. Inheritance is another tool, to perform another task. Don’t be afraid to learn any tool in your toolbox. And don’t sweat about problems you may never have either. And have some things inherit, you’re in good company still

      • Rikudou_Sage
        link
        fedilink
        English
        41 year ago

        I’ve been senior for quite some time now, I know when to use what (most of the time) and yeah, inheritance has its place, though I don’t use it often because most of the time it simply isn’t the right thing to do.

        • @jvisick@programming.dev
          link
          fedilink
          English
          21 year ago

          In my experience, inheritance is really handy in the right situation. But far more often, inheritance is just a quick way to code yourself into a corner or just a waste of mental energy in the wrong place.

      • @philm@programming.dev
        link
        fedilink
        English
        31 year ago

        I can think of maybe 1 or 2 places where inheritance makes sense, and I haven’t encountered these in the last 5 years… (not counting implementing interfaces of course, which definitely makes sense). In all other cases inheritance is IMHO a bad decision (why I think it should not be a thing in programming languages, because it leads someone to write bad code, as it seemed to be the right thing to do…).