¿Es mejor confiar en dependencias transitivas o declararlas explícitamente?

Tengo una estructura de proyecto como esta:

My Project
  - Other Team's Project
     -Third Party Dependency

My Projectrequiere Other Team's Projectfuncionar, y ambos My Projecty Other Team's Projectrequieren Third Party Dependencyfuncionar. Estamos utilizando un sistema de gestión de dependencias para gestionarlos.

Desde una perspectiva de diseño, ¿es mejor My Projectconfiar de forma transitiva Third Party Dependency? ¿O es mejor para ambos My Projecty Other Team's Projectpara ambos declarar explícitamente que usan Third Party Dependency?

Algunas otras cosas:

• Ambos proyectos deben tener la misma versión de Third Party Dependency.
• No se garantiza que si Other Team's Projectse actualiza My Projectse probará para garantizar que nada se rompa, ya que son administrados por diferentes equipos.

Imagine lo que sucede si el otro equipo refactoriza su proyecto para hacer lo mismo sin usar la biblioteca de terceros y eliminan su dependencia. O cambian a otra biblioteca de terceros para hacer lo mismo. ¿Su código seguirá funcionando?

Si lo hace, su código solo depende del otro proyecto, si no, su código también depende de la biblioteca de terceros.

Ambos proyectos deben tener la misma versión de Third Party Dependency.

Ese es un fuerte indicador de que su proyecto también depende directamente de la biblioteca de terceros.

Creo que esto se basa principalmente en la opinión, pero de todos modos pondré mi 2p.

La forma en que siempre lo he hecho es preguntándome, ¿cuál es la cantidad mínima de conocimiento que mi código necesita para hacer lo que se supone que debe hacer?

Si mi código solo usa código de Other team's library, entonces solo lo incluiré Other team's librarycomo una dependencia.

Si mi código también usa código de Third-party library, entonces lo incluiré también.

Digamos que tenía las siguientes clases de My Library, Other Libraryy Third-party Library(voy a utilizar Java para el código de ejemplo)

package mylibrary;

import otherlibrary.Bar;

public class Foo {

    public void doFoo() {
        Bar bar = new Bar();
        bar.doBar();
    }
}

En el Other Library

package otherlibrary;

import thirdparty.Baz;

public class Bar {

    public void doBar() {
        Baz baz = new Baz();
        baz.doSomething();
    }
}

En el Third-party library

package thirdparty;

public class Baz {

    public void doBaz() {
        System.out.println("baz");
    }
}

Debido a que mi código Foosolo depende del código de otherlibrary, eso es todo lo que incluiría, porque eso es todo lo que me importa. No me importa cómo otherlibrary.Bar#doBarhace lo que hace, solo quiero que lo haga.

Sin embargo, si cambiamos el otherlibrary.Bar#doBarpara aceptar un Bazpara hacer algo con, como

public void doBar(Baz baz) {
    baz.doBaz();
}

Entonces necesitaría cambiar mylibrary.Foo#doFooa algo como

public void doFoo() {
    Bar bar = new Bar();
    Baz baz = new Baz();

    bar.doBar(baz);
}

Debido a que ahora estoy interesado en cómo Bar#doBarva a hacer lo suyo, y mi código necesita saber Bazpara hacer lo que quiero que haga, debo ser explícito sobre las bibliotecas que incluyo.

Si mi código debe saber sobre cosas dentro de la thirdpartybiblioteca, entonces debo incluirlo como una dependencia.

Aunque quizás el autor de Bardebería esconder más de esos detalles, así que no necesito incluir la thirdpartybiblioteca ...