Quotes About Dependencies

In addition, build dependencies may not be the same as test dependencies, and you may need separate hierarchies.

I like my code to be elegant and efficient. The logic should be straightforward to make it hard for bugs to hide, the dependencies minimal to ease maintenance, error handling complete according to an articulated strategy, and performance close to optimal so as not to tempt people to make the code messy with unprincipled optimizations. Clean code does one thing well. -Bjarne Stroustrup, inventor of C++ and author of The C++ Programming Language

In fact, wrapping third-party APIs is a best practice. When you wrap a third-party API, you minimize your dependencies upon it:

The Dependency Inversion Principle (DIP) tells us that the most flexible systems are those in which source code dependencies refer only to abstractions, not to concretions.

Clean code can be read, and enhanced by a developer other than its original author. It has unit and acceptance tests. It has meaningful names. It provides one way rather than many ways for doing one thing. It has minimal dependencies, which are explicitly defined, and provides a clear and minimal API. Code should be literate since depending on the language, not all necessary information can be expressed clearly in code alone. -Dave Thomas, founder of OTI, godfather of the Eclipse strategy

In general, it is harmful to depend on modules that contain more than you need. This is obviously true for source code dependencies that can force unnecessary recompilation and redeployment—but it is also true at a much higher, architectural level.

Don't override concrete functions. Concrete functions often require source code dependencies. When you override those functions, you do not eliminate those dependencies—indeed, you inherit them. To manage those dependencies, you should make the function abstract and create multiple implementations.

If its dependencies are inverted, it has an OO design. If its dependencies are not inverted, it has a procedural design.

The SAP and the SDP combined amount to the DIP for components. This is true because the SDP says that dependencies should run in the direction of stability, and the SAP says that stability implies abstraction. Thus dependencies run in the direction of abstraction.

Transitive dependencies are a violation of the general principle that software entities should not depend on things they don't directly use. We'll encounter that principle again when we talk about the Interface Segregation Principle and the Common Reuse Principle.

Why are Entities high level and use cases lower level? Because use cases are specific to a single application and, therefore, are closer to the inputs and outputs of that system. Entities are generalizations that can be used in many different applications, so they are farther from the inputs and outputs of the system. Use cases depend on Entities; Entities do not depend on use cases.

Code at the boundaries needs clear separation and tests that define expectations. We should avoid letting too much of our code know about the third-party particulars. It's better to depend on something you control than on something you don't control, lest it end up controlling you.

THE STABLE DEPENDENCIES PRINCIPLE Depend in the direction of stability.

STABILITY METRICS How can we measure the stability of a component? One way is to count the number of dependencies that enter and leave that component. These counts will allow us to calculate the positional stability of the component.

As useful as services are to the scalability and develop-ability of a system, they are not, in and of themselves, architecturally significant elements. The architecture of a system is defined by the boundaries drawn within that system, and by the dependencies that cross those boundaries.

Instead of causes, biology is repeatedly about propensities, potentials, vulnerabilities, predispositions, proclivities, interactions, modulations, contingencies, if/then clauses, context dependencies, exacerbation or diminution of preexisting tendencies. Circles and loops and spirals and Möbius strips.

Even though the realms of religion and science in themselves are clearly marked off from each other, nevertheless there exist between the two strong reciprocal relationships and dependencies.

the extent of Parliament's authority to legislate for the colonies had not been closely examined by anyone. When it was, it became a center of controversy. The common presumption in England, wholly unexamined, was that all was clear in the colonial relation. The colonies were colonies, after all, and as such they were "dependencies," plants set out by superiors, the "children" of the "mother country," and "our subjects.

How do you test just the one class when that class needs an entourage of other classes to work? What you need are stubs and mocks.

Let's not forget that in the throughput world the linkages are as important as the links. Which means that if we decided to do something in one link, we have to examine the ramifications on the other links.

We've been talking a lot about dependencies. Things you get dependent on ... Smack but also people. You get dependent on people. Like… emotional dependencies. Which are just as addictive. OK?

In software, the chain isn't as strong as its weakest link; it's as weak as all the weak links multiplied together.

I could sense the surge of all those Ambossans who for years had filled those brightly lit tunnels during what they called the Rushing Hour. All those scurrying feet and harried minds. All those sugar-loving, coffee-drinking, baccy-smoking, rum-sipping commuters, most of whom hadn't a thought about who provided their little pleasures, their little dependencies.

A state too extensive in itself, or by virtue of its dependencies, ultimately falls into decay; its free government is transformed into a tyranny; it disregards the principles which it should preserve, and finally degenerates into despotism. The distinguishing characteristic of small republics is stability: the character of large republics is mutability.