News for hackers. Stuff that matters.
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.