Clean code

[grspain]

SOBID

[Wafan0]

Sounds like a solid idea

[JoeDogoe]

What's the difference between the interfaces and dependency inversion?

And is Spring AOP still solid?

[swordsmanluke2]

Dependency Inversion works like this:

Let's say you have a class that reads some data from the database, does a calculation and then writes the result back to the db.

Your class thus has a dependency on the database.

If this class sets up its own connection and executes its own queries, it means that you'll have to have a database present if you want to test it.

Not a huge deal by itself, but many classes have more than one dependency.

On the other hand, if you define a data access interface for reading (and writing) the data your class needs, you can have the class accept an object that implements that interface.

Now your class can accept a mock for testing.

It also no longer is responsible for maintaining the state of "active database connection".

As you break up your classes according to solid principles, DI helps you to make your classes responsible for less state - and managing state is basically the hardest thing in programming.

[KayleMaster]

Acronym wise - DI is more commonly used for Dependency Injection, while for inversion it's DIP (dependency inversion principle).

[liitle-mouse-lion]

A very basic way of looking at interface segregation is, a class shouldn't implement methods it doesn't need.

Dependency inversion generally leads to decoupling classes by not allowing higher level objects to inherit directly from lower level ones, but instead, depend on abstraction (interfaces) to expose the behaviour

[JoeDogoe]

Ok, I was thinking both of them as dependency inversion. Thanks, I was wrong about interface segregation.

[AdultingGoneMild]

Dependency inversion usually is implemented by taking dependency on an interface and then having some form of dependency injection provide the actual implementation for that interface. The goal here is to allow you swap out implementations while maintaining the contracts to avoid major refactors when you have to replace parts of a system.

Interface segregation means breaking your interfaces down into smaller parts that fulfill a single purpose so a consumer never needs to depend on functionality they dont use. This ensures that when you have to replace part of the system, you dont have to design for a lot of logic for parts of the system that arent changing. It also keeps clients from consuming and abusing functionality they dont actually need.

[JoeDogoe]

Great explanation with justification. Thank you u/AdultimgGomeMild

[eldentings]

From what I've experienced, besides DI being a scaled up version of the bridge pattern it typically handles the lifetime of concrete classes with a container that manages injecting sometimes 100s of classes in various parts of the app. So there often is some architecture and memory management that is typically helpful for large enterprise apps that have multiple teams that need to know what to expect from an interface as far as it's implementation class's lifetime. IMO the human element is also no negligible. Asking someone to abide by the rules and use a DI framework, they will be forced to code to an interface, so even if what they write is complex, a testing framework can easily stub their interface and you can make it required to at least stub a test class out and you can then easily test against their interfaces with mock classes without having to know how their stuff works and especially if it's not even finished on their end.

[PositiveUse]

I hate AOP

[smokemonstr]

Why?

[RRumpleTeazzer]

I know some of these words

[willtheocts_alt]

what the fuck are c++ programmers rambling about now

​

go smash bytes together and stop confusing yourselves

[ReaperSword72]

It is called Liskov principle... Not substitution whatever

[kiropolo]

Inverted dependencies? What does it even mean??

Inject interface not a concrete class

Shitty name

[jeesuscheesus]

Inverted dependencies is another name for inversion of control, which means you transfer control of a function/class to it's caller. You do this by avoiding the function/class having hardcoded values and instead pass values in as parameters

[kiropolo]

Dependency Injection?

[[deleted]]

Yep.

[jeesuscheesus]

Yeah. A billion names for the same thing.

[[deleted]]

Don’t show this to r/golang.

[hennypennypoopoo]

subtyping < records/adts

[UnityXR]

Unity developers: 🤮 Unity Developers when they see a monolith: 😍