Most people know that software engineering is an exact science in the way it behaves. What those peering at software solutions from the outside don't know is that software solutions are somewhat religious in nature because of the several leaps of faith that the code makes. A truly efficient software solution is loosely coupled, which basically means that the software solution is broken down into several pieces that work in harmony. Depending on the size and scope of the project, some parts of the solutions are pulled in from external sources.

ENTERPRISE SOLUTIONS ARE BUILT TO TRUST IN THEIR DIFFERENT UNITS

Enterprise solutions are built in such a way that they require some services to work. Dependency injection is more or less what happens when you provide services that a program needs. What's more mindboggling is that the program doesn't even know about the service(s) being injected, how to create that service or which service that it's using. For context, those of us who were taught how to ride can attest to the fact that we were handheld for a bit after which we were "assured" that we were being held from behind (meanwhile we weren't), that assurance gave us the confidence to ride till we didn't need any help.

DEPENDENCY INJECTS HELPS IN DECOUPLING AND SCALABILITY

Dependency injection helps with ensuring that critical services that a software solution needs (but doesn't know about) are provided. A software engineer cannot know it all, if we have to build everything from scratch a project will be built indefinitely. A lot of services have been created to help speed up development. Just like the program, software engineers don't have to know exactly how the services work, asides from the fact that the services are needed. There are some utilities that have to be built by the software engineer. When software solutions are made loosely coupled this way, it makes it easier to test the code, fix bugs, and extend the features of these software solutions.