Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Import as an antipattern - Demystifying Depende...

Import as an antipattern - Demystifying Dependency Injection in Python

Dependency Injection in Python is commonly seen as over-engineering, but I think this is a myth. DI is simple and powerful and can yield great benefits to the overall quality of your code.

Dependency Injection (DI) is a technique quite common in other programming languages that has never quite fitted into the Python programmer's mindset. Usually disregarded as over-engineering and complex, most of its alleged flaws have little to do with the underlying concepts but more with implementation details of large scale frameworks that obscure its core principles.

In my experience DI is simple and powerful and can greatly improve our design making our code is easier to test, extend and maintain.

In this talk I will start with a brief standard example and challenge common idioms that introduce coupling and reduce maintainability and extensibility. I will then introduce concepts like interfaces, inversion of control and DI and apply them showcasing how the design and overall quality of the code improves.

Along the way I will demonstrate how recent additions to Python and its tooling can help when applying these techniques and also address the common misconception among Python developers suggesting large complex frameworks are required to apply DI.

I will then share some examples of Dependency Injection in well known libraries and some hands-on stories where I have benefited from it in my day-to-day work. And finally I will provide some guidelines on identifying situations where DI shines and where its application might be less obvious or should be delayed until further domain knowledge is introduced.

With this talk I hope to demystify the Dependency Injection in the Python ecosystem as well as introduce and clarify important design concepts for a beginner to intermediate audience.

Yeray Díaz Díaz

September 15, 2019
Tweet

Other Decks in Programming

Transcript

  1. ! I’m Yeray • Freelance Software Engineer based in London

    • Co-organizer of London Python Meetup • Moderator and contributor for PyPI
  2. What is an abstraction? •A formal interface definition •A series

    of objects that implement that interface •Encapsulating the lower level details
  3. What just happened? •FileProcessor now has one responsibility: compute the

    hash of file contents •It no longer instantiates the repo, this responsibility is moved to the caller
  4. Where do dependencies come from? • One place where all

    instances of all dependencies are created • The Composition Root • Usually at the entry point of our application
  5. Boundary tests •Isolated from changes in the business logic •We

    test that it implements the interface correctly •Will not change at all if the interface is stable •Possibility for integration tests
  6. Bonus principles • Dependency Inversion 
 Principle • Single Responsibility


    Principle • Interface Segregation
 Principle ✅ ✅
  7. Bonus principles • Dependency Inversion 
 Principle • Single Responsibility


    Principle • Interface Segregation
 Principle ✅ ✅
  8. Pure DI •DI Frameworks aim to simplify the composition •DI

    containers vs Pure DI •DI containers are NOT required
  9. Where does DI shine? •Where the abstraction is clear •Runtime

    dependencies and boundaries •Business logic abstractions may be harder to define and costly to backtrack
  10. Conclusions •Every import of an external library is creating coupling

    •Consider the responsibility that’s being fulfilled •Abstract only if it’s obvious •You do not need to go all-in with frameworks, DI can be applied gradually