News for hackers. Stuff that matters.
Re:Printf(“%s %s”, dependency, injection) by LukeShu on Tuesday October 19, 2021 @05:39AM (#28916384)
Dependency Injection is just passing arguments.

If you're writing a library that does things that involve talking to a database:

- Not DI: You `import Database.PostgreSQL.Simple` and your function(s) take the appropriate arguments to pass to postgresql-simple.

- DI: Rather than you `import`ing a library to talk to a database, you take an argument that is an object/function (a partially-applied `connectPostgreSQL`? an instance of a typeclass?) that you use to talk to the database.

(IDK if the various SQL libraries for Haskell are compatible enough with each other to make that example particularly realistic)

Instead of using a library, you take an implementation as an argument. That's all DI is.

Re:Printf(“%s %s”, dependency, injection) by nerdponx on Tuesday October 19, 2021 @06:35AM (#28916675)
Right, I think functional programmers like to trivialize the actual usefulness and value of "dependency injection" as a standalone concept.

Here's a Python example without DI:

    class MyClient:
        def __init__(self):
            self.http_client = httpx.Client()
And the DI version, which is a small change with big consequences (especially for testing; no more patching!):

    class MyClient:
        def __init__(self, http_client=None):
            self.http_client = self.http_client or httpx.Client()
Re:Printf(“%s %s”, dependency, injection) by Sohcahtoa82 on Tuesday October 19, 2021 @12:45PM (#28920232)

    self.http_client = self.http_client or httpx.Client()
should be:

    self.http_client = http_client or httpx.Client()
But yeah, once I learned that DI can be summed up into what you put here, I realized that DI is a $1,000 term for a $5 concept that has $100,000 ramifications in terms of what it enables you to do.
Re:Printf(“%s %s”, dependency, injection) by Spivak on Tuesday October 19, 2021 @03:10PM (#28922260)
Python also has a really nice pattern using classes for this. I've heard it called the supply chain pattern before.

    class MyClient(HTTPClient):
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

        def do_some_networking(self, arg):
            super().http_get("server", arg)

    class MyClientWithDI(MyClient, MyHTTPClient):
        pass

    client = MyClientWithDI()
    # Will call MyHTTPClient's http_get
    client.do_some_networking("/status")
Re:Printf(“%s %s”, dependency, injection) by nerdponx on Tuesday October 19, 2021 @06:51PM (#28924732)
I've actually never seen this one before, and I'm not sure if I like it. I generally tend to favor "composition over inheritance", and I'm not sure what the advantage of inheritance is in this case, compared to standard DI.
Re:Printf(“%s %s”, dependency, injection) by eru on Wednesday October 20, 2021 @08:27AM (#28929822)
Python's threads used to work like that, for example. (They still have that as an option, but I think the composition is more preferred these days?)
Re:Printf(“%s %s”, dependency, injection) by nerdponx on Wednesday October 20, 2021 @09:10AM (#28930229)
The old-school way to use Thread is to subclass it and override some methods. The post here is describing a setup where you don't override methods, but instead provide some kind of mixin. I've never seen anyone write this, for example:

    class MyThreadImpl:
        def run(self):
            do_stuff()

    class MyThread(Thread, MyThreadImpl):
        pass
Re:Printf(“%s %s”, dependency, injection) by eru on Wednesday October 20, 2021 @01:28AM (#28927084)
> Right, I think functional programmers like to trivialize the actual usefulness and value of "dependency injection" as a standalone concept.

Not sure? Eg Haskell typeclasses (and that includes monads!) could mostly be replaced by just passing arguments around (basically a bit like a vtable in C++). But it would make the ergonomics almost unusable.

Of course, many real world functional programmers (or wanabe functional programmers) like to make fun of OOP.

Re:Printf(“%s %s”, dependency, injection) by gpderetta on Tuesday October 19, 2021 @06:23AM (#28916625)
and passing a factory is just call-by-name/call-by-need.
Re:Printf(“%s %s”, dependency, injection) by eru on Wednesday October 20, 2021 @01:28AM (#28927089)
Well, factories are really just functions.