What is the relationship between ADP and Dependency Inversion Principle (DIP)?

What is the relationship between ADP and Dependency Inversion Principle (DIP)?

• A. They are identical; ADP is a subset of DIP.
• B. ADP requires global state; DIP requires singletons.
• C. ADP focuses on acyclicity; DIP focuses on depending on abstractions; they complement each other.
• D. DIP enforces cycles; ADP forbids interfaces.

Answer: (C)

Acyclic Dependencies Principle (ADP) and Dependency Inversion Principle (DIP) address different but related concerns about how parts of a system depend on each other. ADP says the dependency graph between modules should be acyclic—no circular dependencies—because cycles make code harder to change, test, and reason about. DIP says high-level modules shouldn’t depend on low-level details; both should depend on abstractions, and concrete implementations should depend on those abstractions rather than the other way around. They fit together because depending on abstractions (DIP) helps break potential cycles and makes the dependency graph easier to untangle, which supports maintaining an acyclic structure (ADP). For example, if a high-level module depends on a concrete low-level class, you risk a cycle or tight coupling; by introducing an interface or abstract layer (an abstraction) that both sides depend on, you keep the graph direction clear and can rewire implementations without creating cycles. The other options aren’t correct because ADP and DIP are not identical; ADP isn’t about global state or singletons, and DIP isn’t about enforcing cycles or forbidding interfaces.

Acyclic Dependencies Principle (ADP) and Dependency Inversion Principle (DIP) address different but related concerns about how parts of a system depend on each other. ADP says the dependency graph between modules should be acyclic—no circular dependencies—because cycles make code harder to change, test, and reason about. DIP says high-level modules shouldn’t depend on low-level details; both should depend on abstractions, and concrete implementations should depend on those abstractions rather than the other way around.

They fit together because depending on abstractions (DIP) helps break potential cycles and makes the dependency graph easier to untangle, which supports maintaining an acyclic structure (ADP). For example, if a high-level module depends on a concrete low-level class, you risk a cycle or tight coupling; by introducing an interface or abstract layer (an abstraction) that both sides depend on, you keep the graph direction clear and can rewire implementations without creating cycles.

The other options aren’t correct because ADP and DIP are not identical; ADP isn’t about global state or singletons, and DIP isn’t about enforcing cycles or forbidding interfaces.