Acho que isso é principalmente baseado em opiniões, mas eu colocarei meus 2p de qualquer maneira.
A maneira como sempre fiz isso é me perguntando, qual é a quantidade mínima de conhecimento que meu código precisa ter para fazer o que deveria fazer?
Se meu código usa apenas código de Other team's library
, incluirei apenas Other team's library
como dependência.
Se meu código também usa código de Third-party library
, também o incluirei.
Vamos dizer que eu tinha as seguintes classes de My Library
, Other Library
e Third-party Library
(eu vou usar Java para o código de exemplo)
package mylibrary;
import otherlibrary.Bar;
public class Foo {
public void doFoo() {
Bar bar = new Bar();
bar.doBar();
}
}
No Other Library
package otherlibrary;
import thirdparty.Baz;
public class Bar {
public void doBar() {
Baz baz = new Baz();
baz.doSomething();
}
}
No Third-party library
package thirdparty;
public class Baz {
public void doBaz() {
System.out.println("baz");
}
}
Como o meu código Foo
depende apenas do código otherlibrary
, isso é tudo o que eu incluiria, porque é com isso que eu me importo. Eu não me importo como otherlibrary.Bar#doBar
faz o que faz, só quero que faça.
Se, no entanto, alteramos a opção otherlibrary.Bar#doBar
de aceitar um Baz
para fazer algo, como
public void doBar(Baz baz) {
baz.doBaz();
}
Eu precisaria então mudar mylibrary.Foo#doFoo
para algo como
public void doFoo() {
Bar bar = new Bar();
Baz baz = new Baz();
bar.doBar(baz);
}
Como agora estou interessado em como Bar#doBar
as coisas funcionam, e meu código precisa saber Baz
o que quero fazer, preciso ser explícito sobre as bibliotecas que incluo.
Se o meu código deve saber sobre o material dentro da thirdparty
biblioteca, então eu deve incluí-lo como uma dependência.
Embora talvez o autor de Bar
deva esconder mais desses detalhes, não preciso incluir a thirdparty
biblioteca ...
thirdyparty
versão 4 eotherlibrary
precisar da versão 3. O que vocês fazem sobre isso?