Por que preferir um gerenciador de pacotes a uma pasta da biblioteca?

68

Quando penso nos prós e contras de uma pasta estática da biblioteca e de um gerenciador de pacotes, sinto que a pasta da biblioteca é uma abordagem melhor.

Prós que vejo em uma pasta da biblioteca:

  1. Não há necessidade de uma ferramenta externa para gerenciar pacotes.
  2. Não requer conexão com internet para construir.
  3. Construção mais rápida (sem verificação de pacotes).
  4. Ambiente mais simples (menos conhecimento necessário).

Prós que vejo com um gerenciador de pacotes:

  1. Ajuda com árvores de dependência complexas (e que podem ser gerenciadas baixando uma dependência junto com todas as suas dependências).
  2. Ajuda a verificar se há uma nova versão disponível.

Parece que o setor decidiu seguir o caminho do gerenciador de pacotes para quase tudo o que é construído atualmente. Então, o que estou perdendo?

Ignacio Soler Garcia
fonte
33
Acho que você está realmente perguntando sobre os benefícios de agrupar versus exigir bibliotecas. Você obterá respostas mais relevantes se usar esses termos.
Kilian Foth
3
O que está impedindo você de criar um contêiner de docker para o agente de construção, contendo tudo o necessário e possivelmente nem mesmo permitindo acesso à Internet (que não deveria ser necessário para a construção)? Eu acho que você é mais contra aprender uma nova ferramenta do que realmente considerar argumentos. Você já trabalhou em um grande projeto que usa dependências gerenciadas manualmente? Não é tão bom quanto você parece.
Kayaman
3
@Kayaman: aprender uma nova ferramenta custa tempo (dinheiro) da equipe e eu gostaria de verificar se estamos investindo na coisa certa. Minha experiência com grandes projetos é que as dependências são bastante estáveis ​​[quase nunca mudam] e talvez seja por isso que um gerenciador de pacotes pareça caro para mim. Enfim, eu estava apenas listando prós e contras depois de trabalhar um tempo com Nuget e passar algum tempo com ele.
Ignacio Soler Garcia
2
@sebkur Você pode manter cópias locais de todos os seus pacotes. Mantemos as versões atuais de todas as nossas dependências sob controle de fonte local. O único momento em que o gerenciador de pacotes precisa de uma conexão é quando fazemos atualizações.
17 de 26
11
@ 17of26: você não aprende como configurar um agente de construção para instalar o nuget e executá-lo mediante solicitação em 10 minutos. Você também não tem um projeto de várias soluções em que os mesmos projetos são usados ​​em soluções diferentes.
Ignacio Soler Garcia

Respostas:

122

Um ponto importante ausente nas outras respostas:

Usar um gerenciador de pacotes significa ter uma configuração que indica quais versões da biblioteca você está usando e garante que as informações de configuração estejam realmente corretas.

Saber quais bibliotecas você usa e qual versão é muito importante se:

  • precisa atualizar uma biblioteca devido a uma falha crítica de bug / segurança;
  • ou apenas precisa verificar se uma falha de segurança anunciada afeta você.

Além disso, quando você realmente atualiza, o gerenciador de pacotes (geralmente) garante que todas as dependências transitivas sejam atualizadas conforme necessário.

Considerando que, com uma libpasta, você só tem um monte de arquivos (possivelmente binários e possivelmente modificados) e precisará adivinhar de onde eles vieram e qual versão eles são (ou confiar em alguns README, que podem ou não estar corretos )


Para abordar seus outros pontos:

Não há necessidade de ferramenta externa para gerenciar pacotes.

É verdade, mas a) como desenvolvedor de software, você precisa instalar cargas de ferramentas de qualquer maneira; portanto, mais uma não importa, eb) geralmente existem apenas um ou alguns gerenciadores de pacotes em qualquer campo (Maven / Gradle for Java, npm para JS / TypeScript, etc), por isso não é necessário instalar dezenas deles.

Não requer conexão com internet para construir.

Todos os gerenciadores de pacotes que conheço trabalham off-line, depois de baixar as dependências necessárias (o que pode acontecer logo após o download do próprio projeto).

Construção mais rápida (sem verificação de pacotes).

Provavelmente é verdade, mas parece improvável que a verificação do pacote offline leve uma quantidade significativa de tempo (é só comparar alguns números de versão). Uma verificação online pode demorar um pouco, mas pode ser desativada, se desejado (se estiver ativada por padrão - o Maven, por exemplo, nunca verifica atualizações de versões).

Ambientes mais simples (menos conhecimento necessário).

Verdade, mas como explicado acima, uma libpasta também requer conhecimento. Além disso, como explicado acima, você provavelmente trabalhará apenas com alguns gerenciadores de pacotes diferentes, que você já conhece.

sleske
fonte
170
“Não há necessidade de ferramenta externa para gerenciar pacotes” - sim. Agora é o trabalho do seu cérebro. Boa sorte, cérebro!
Paul D. Waite
57
Qualquer pessoa que pense seriamente que ter uma pasta lib é um "ambiente mais fácil" deve simplesmente seguir em frente e tentar descobrir a árvore de dependências, por exemplo, o nuget Microsoft.AspNetCore.All . Vá em frente, não espere por mim, voltarei daqui a um dia.
Voo
13
Além disso, o navegador da Internet usado para procurar bibliotecas manualmente contaria como uma ferramenta externa para gerenciar pacotes. Juntamente com tudo o mais que você usa (gerenciador de arquivos do SO, etc.) para preparar e posicionar as bibliotecas. Portanto, a verdadeira escolha é uma ferramenta externa (gerenciador de pacotes) versus muitas.
NemesisX00
3
Apenas para sua informação, tentei recentemente trabalhar com o gradle em um PC offline. Sem sorte, o Android Studio não executará meu aplicativo e recebo uma mensagem de erro obscura e foi depois que fiz uma primeira execução online para dependências. É apenas nesses tipos de situações quando você realmente perceber como dependente de gerenciadores de pacotes que criam software tornou-se ...
FROB
7
@ PaulD.Waite Enquanto estamos nisso, nos livramos daquelas "linguagens" traquinas que todo mundo fala. De qualquer forma, tudo se resume ao código da máquina, então, na minha empresa, cortamos o intermediário. Agora isso é eficiência!
corsiKa
39

Os profissionais da pasta lib desaparecem rapidamente depois que você passa do desenvolvimento em pequena escala para um trabalho maior.

Por exemplo, o "benefício" de não exigir uma ferramenta externa é superado pelo trabalho necessário para gerenciar manualmente suas dependências; portanto, a ferramenta será você (em mais de um sentido do mundo).

Você não precisa de uma conexão com a internet para gerenciar um pacote. Você pode usar repositórios locais.

Uma construção mais rápida pode ser verdadeira, mas dificilmente é algo que deve determinar se você deve usar um gerenciador de pacotes ou não. Afinal, não estamos falando de magnitudes de diferença, e isso também depende da sua configuração. Você pode facilmente criar uma compilação lenta usando um gerenciador de pacotes, mas isso é basicamente sabotagem.

Ambientes mais simples (menos conhecimento necessário)? Mais uma vez, no desenvolvimento em pequena escala, definitivamente, uma possibilidade. Você pode manter o projeto em sua cabeça completamente, até cada uma das poucas bibliotecas que estão sendo usadas. Adicione um script simples de makefile / outro e você terá um pacote completo.

Mas isso não torna os ambientes mais simples, apenas funciona em ambientes simples. No desenvolvimento em larga escala, você ficará feliz por usar ferramentas padrão em vez de soluções personalizadas. Afinal, você só precisa aprender uma vez (e quando o gerenciador de pacotes do dia é substituído pelo novo e interessante, você também precisa aprender).

Kayaman
fonte
21
@IgnacioSolerGarcia: Só é mais fácil se nada der errado. E se a nova versão da biblioteca A também precisar de um B e C atualizado? E se você ainda rodar, mas apresentar erros sutis? Isso tudo faz parte do "gerenciamento de dependências".
sleske
18
@IgnacioSolerGarcia dizendo "baixar um arquivo" não pinta a imagem correta. Digamos "faça o download de 20 arquivos e verifique se as versões deles são compatíveis". Nenhum trabalho evitado lá. A atualização de pacotes também não é uma situação teórica, a menos que você tenha decidido congelar as versões de dependência e esteja pronto para aceitar os possíveis problemas (bugs, falhas de segurança) resultantes disso.
Kayaman
12
@IgnacioSolerGarcia "baixar um arquivo" - você quis dizer (1) encontrar o site do projeto correto (alguns estão hospedados no github, outros no sourceforge, outros no próprio site), (2) acessar a página de download, (3) encontrar a versão correta , (4) faça o download, (5) descompacte e solte em algum lugar. Isso parece muito mais trabalho do que blah install libfoo. E então, multiplique por, digamos, 5 dependências.
el.pescado
5
@IgnacioSolerGarcia Ok, quais arquivos eu "simplesmente" tenho que baixar para que esse nuget funcione corretamente? E essa é basicamente a configuração mais trivial para um projeto ASP.NET Core. Na prática, você terá muito mais dependências.
Voo
6
@ Ignacio Esse é o meta nuget básico para colocar em execução o aplicativo ASP.Net Core mais simples. É verdade que nos velhos tempos da estrutura completa tudo era "mais fácil", porque você tinha grandes bibliotecas monolíticas que eram todas versionadas ao mesmo tempo e o lançamento de uma atualização levou anos. Esse modelo ficou basicamente obsoleto por boas razões, não apenas no mundo .NET. Você terá que se acostumar com todo o modelo de muitas bibliotecas pequenas fazendo uma coisa específica e honestamente, usar um gerenciador de pacotes é a parte mais fácil da transição.
Voo
35

Você está perdendo muitas das vantagens dos gerenciadores de pacotes.

  1. Os gerenciadores de pacotes permitem evitar a verificação de binários grandes (vários megabytes ou maiores) no controle de origem. Fazer isso é um anátema para muitas ferramentas de controle de origem, sendo o git generalizado um deles. Tivemos um repositório atingido os limites de tamanho do Bit Bucket alguns meses atrás porque os desenvolvedores estavam verificando os CocoaPods. Outro projeto já estava no meio do caminho quando migramos do SVN porque estávamos fazendo o check-in de todos os nossos binários de lib (e não estávamos usando o NuGet). Como os gerentes de pacotes baixam pacotes rapidamente para cada desenvolvedor, eles eliminam a necessidade de verificar esses binários.
  2. Eles impedem a mistura de arquivos / bibliotecas incompatíveis. As pastas podem conter versões mistas dos arquivos da biblioteca se alguém não a limpar adequadamente durante uma atualização. Eu vi um caso em que metade dos binários na pasta foram atualizados, resultando em erros muito estranhos. (Ele nem travou!) Levamos literalmente meses (não horas de trabalho, apenas tempo total) para descobrir o problema. Ao deixar o gerenciador de pacotes controlar a pasta inteira, você não pode obter versões mistas; você garante consistência. Eles também tornam muito mais difícil o uso de dependências incompatíveis , atualizando tudo automaticamente, instalando versões diferentes quando necessário ou apenas lançando avisos ou erros ao tentar usar versões incompatíveis de bibliotecas.
  3. Eles estabelecem uma convenção compartilhada para gerenciar bibliotecas. Quando novos desenvolvedores entram em seu projeto, equipe, empresa etc., é provável que conheçam as convenções do gerente de pacotes. Isso significa que eles não precisam perder tempo descobrindo os detalhes de como as bibliotecas são gerenciadas em sua base de código.
  4. Eles oferecem uma maneira padrão de versionar e distribuir suas próprias dependências e arquivos que não pertencem ao seu repositório. Eu os utilizei pessoalmente para alguns grandes arquivos de dados estáticos exigidos pelo meu aplicativo, para que funcione bem na versão de versões além do código binário.
  5. Alguns gerenciadores de pacotes fornecem recursos adicionais durante a instalação. O NuGet adicionará dependências e arquivos de conteúdo ao seu arquivo csproj e pode até adicionar elementos de configuração ao arquivo de configuração.
  6. Os arquivos da lista de pacotes documentam as versões de suas bibliotecas em um único local centralizado. Não preciso clicar com o botão direito do mouse em uma DLL e olhar o número da versão para descobrir qual versão da biblioteca estou usando. No Python, o autor da biblioteca pode nem ter incluído o número da versão nos arquivos py, portanto, talvez eu nem consiga diferenciar a versão da biblioteca a partir deles.
  7. Eles desencorajam a instalação de dependências em toda a máquina. Os gerenciadores de pacotes fornecem uma maneira convencional de instalar dependências sem um instalador global . Quando suas opções são pasta lib e instalação global, muitos desenvolvedores de bibliotecas optam por oferecer suas bibliotecas primárias como instalações globais, em vez de binários para download que você precisa configurar por conta própria. (O histórico da MS demonstra isso. Também é o caso de muitas bibliotecas no Linux.) Isso realmente torna o gerenciamento de vários projetos mais difícil, pois você pode ter projetos com versões conflitantes e alguns desenvolvedores certamente escolherão a instalação global aparentemente mais simples do que ter sua própria biblioteca dir.
  8. Eles tendem a centralizar a hospedagem e a distribuição. Você não precisa mais depender do site da biblioteca aleatória. Se eles falirem, o site de um gerenciador de pacotes bem-sucedido ainda terá todas as versões já carregadas. Os desenvolvedores também não precisam procurar muitos sites apenas para baixar novas bibliotecas; eles têm um local para procurar primeiro e até procurar opções diferentes. Também é mais fácil espelhar pacotes organizados de maneira padrão do que hospedar manualmente cópias de tudo, de sites ad-hoc.

Você também está exagerando o valor dos seus "benefícios".

  1. Não há necessidade de ferramenta externa para gerenciar pacotes.

    "Externo" para quê? Verifico o executável do NuGet nos meus repositórios. É o único binário em que me sinto bem ao fazer o check-in, já que é pequeno e significa que não preciso fazer check-in de outros binários.

    O pip não apresenta problemas nessa frente, já que agora está empacotado com o Python e as alterações incompatíveis e reversas são extremamente raras. Você não vai desenvolver código Python sem ter o Python instalado externamente no seu projeto, de qualquer maneira.

    Quando alcançam ampla adoção, os gerentes de pacotes tendem a ser muito estáveis. Você não pode fugir sem algum tipo de ferramenta instalada globalmente para a maioria dos projetos, e um único gerenciador de pacotes é um requisito bastante leve. Geralmente, não é muito mais complicado do que ter o tempo de execução do idioma instalado.

  2. Não requer conexão com internet para construir.

    Não consigo me conectar ao meu banco de dados sem uma conexão de rede. Se o banco de dados estiver hospedado na Amazon, preciso de uma conexão completa com a Internet. Preciso de uma conexão com a Internet para enviar e receber alterações através do controle de origem; um servidor de compilação também não pode fazer check-out do código para compilar sem algum tipo de conexão de rede. Você não pode enviar ou receber email sem um. Você não pode baixar bibliotecas para colocá-las na sua pasta lib sem uma! O desenvolvimento permanente sem uma conexão à Internet é praticamente inédito. Em alguns casos raros em que é necessário, você pode lidar com isso baixando os pacotes para um local que o gerenciador de pacotes possa consumir. (Eu sei que o NuGet e o pip estão felizes em extrair de uma simples pasta ou unidade de rede; suspeito que a maioria dos outros também possa.)

  3. Construção mais rápida (sem verificação de pacotes).

    30 segundos durante a compilação automatizada e 5 segundos durante as compilações de desenvolvedores locais são uma boa opção para os benefícios que descrevi acima. Esses são prazos triviais que geralmente nem valem a pena considerar em comparação com os problemas que os benefícios resolvem.

  4. Ambientes mais simples (menos conhecimento necessário).

    Uma ferramenta para o gerenciamento de pacotes e nada para o gerenciamento de bibliotecas não é realmente uma comparação justa. Sem a ferramenta, você precisa aprender qualquer processo personalizado que o projeto esteja usandopara gerenciar suas bibliotecas. Isso significa que você nunca tem certeza se o seu conhecimento existente se aplica a qualquer novo projeto que abordar. Você terá que lidar com qualquer abordagem de miscigenação criada por alguém ou criar a sua. Pode ser um diretório que contém todas as bibliotecas ou pode ser algo muito mais estranho. Talvez, para evitar o check-in das bibliotecas, alguém as coloque em uma unidade de rede e o único indicador de versão seja o nome da pasta. Como é isso ou uma instalação global realmente melhor? Por comparação, um gerenciador de pacotes oferece uma convenção limpa que será aplicada à maioria dos projetos que você encontrar.

O tema comum é que eles fornecem consistência, documentação e recursos, não apenas nos projetos, mas também entre eles. Isso simplifica a vida de todos.

jpmc26
fonte
10
"Desenvolver-se permanentemente sem uma conexão à Internet é praticamente inédito" Eu gostaria de não conhecer melhor. Há muito desenvolvimento feito em redes completamente separadas devido a razões de segurança. Sim, é tão divertido quanto parece, mas é absolutamente factível. Você apenas precisa configurar sua própria infraestrutura para armazenamento de pacotes (ou seja, seu próprio feed de pepitas).
Voo 13/06
11
Embora ter sua própria infraestrutura seja, na verdade, uma das poucas coisas que faz sentido em qualquer caso: você não deseja ser confiável na infraestrutura externa. Se esse não estiver disponível por um motivo ou outro, é muito melhor ter um fallback que garanta que seus desenvolvedores possam continuar a desenvolver. (E antes que alguém me diz como que nuget.org ou npm ou <inserir repo pacote favorito> nunca iria ter esses problemas, talvez pense novamente .)
Voo
3
@IgnacioSolerGarcia Estabelecer uma convenção por projeto ou por departamento ou por empresa não é melhor do que apenas ter uma convenção que todos conhecem sem que sejam informados. Além disso, o gerenciamento de pacotes executa melhor a aplicação da convenção, uma vez que torna a execução da convenção menos trabalhosa do que quebrá-la. Além disso, como mencionei, comprometo o NuGet diretamente e o invoco no script de construção, para que não seja necessário instalá-lo. Eu mantenho as instalações do servidor de compilação em um mínimo realmente simples.
jpmc26
2
@ jpmc26 Se sua primeira lista numerada se beneficiaria de alguma ênfase .
Søren D. Ptæus
11
@ SørenD.Ptæus Feito.
jpmc26
16

Tendo convertido recentemente nosso produto do uso de bibliotecas baixadas manualmente para o gerenciamento automático de pacotes com o Nuget, posso dizer que o uso de um gerenciador de pacotes traz enormes benefícios.

Nosso produto é implementado em 27 projetos C #, que são relativamente pequenos para os padrões atuais. Algumas de nossas dependências de terceiros têm dezenas de assembléias.

Antes do Nuget, se eu quisesse atualizar todas as nossas dependências para a versão mais recente, teria que:

  1. Rastrear onde eu poderia obter todas as bibliotecas atualizadas
  2. Faça o download e descompacte / instale
  3. Adicione as novas versões ao controle de origem
  4. Examine manualmente todas as referências em nossos projetos e atualize-as para apontar para as novas montagens

Com 27 projetos e dezenas de assemblies de dependência, esse processo era muito propenso a erros e poderia levar horas.

Agora que atualizamos o Nuget, tudo foi feito para mim com um único comando.

17 de 26
fonte
Concordo, esse é o ponto 2 dos profissionais. De qualquer forma, mudar dependências é algo que raramente fazemos (provavelmente devido à falta de testes de regressão automatizados adequados).
Ignacio Soler Garcia
9
Atualizar dependências é algo muito menos doloroso de fazer se você fizer isso regularmente.
17 de 26
11
Esses testes são automatizados? Exatamente quanto tempo eles levam para correr? Mesmo que demore 24 horas para executar o conjunto completo de testes, isso ainda permite que você atualize dependências a cada poucos dias com pouca desvantagem (embora você provavelmente não faça isso com tanta frequência na prática). Mesmo que sejam manuais e inevitáveis, usando a instalação manual, você pode passar dias executando os testes apenas para descobrir que eles falham porque você perdeu alguma dependência de uma dependência; então, é necessário reiniciar novamente após a instalação, o que não aconteceria usando gerenciamento de pacotes ...
Sean Burton
3
Você não precisa de testes de regressão em novas versões de software? Atualize as dependências quando você já estiver testando uma versão.
17 de 26
4
"Não os temos totalmente automatizados e a ferramenta é grande demais para fazê-lo (pode levar meses testando ou automatizando)" - esse é o seu grande problema. Esses testes deveriam estar em vigor desde o início. Seu problema não é que o uso de gerenciadores de pacotes não oferece benefícios, mas o contexto em que você está trabalhando é muito quebrado de outras maneiras para permitir que você os aprecie.
Ant P
14

Não há necessidade de ferramenta externa para gerenciar pacotes

Isso é meio inútil, não é? Se eu usar um gerenciador de pacotes, não preciso ter uma pasta lib. Eu também não preciso gerenciar os pacotes sozinho.

Não requer conexão com internet para construir

Além de não ter hoje uma conexão com a Internet durante o desenvolvimento, é um tanto raro (talvez com exceção de estar em trânsito), um gerenciador de pacotes decente não deve exigir que você tenha a versão mais recente para compilar seu aplicativo. Pode reclamar, mas não há razão para não criar com a versão que já instalou

Construção mais rápida (sem verificação de pacotes)

Esse é um aumento de velocidade bastante marginal, mas você pode argumentar sobre isso.

Ambientes mais simples (menos conhecimento necessário)

Atualmente, a maioria dos gerenciadores de pacotes é tão simples que dificilmente vale a pena tentar contorná-los fazendo isso. Existem até clientes visuais, se você quiser. Na verdade, eles escondem grande parte da croft que está acontecendo.

Os gerenciadores de pacotes também permitem que você compartilhe esses pacotes entre diferentes projetos. Se cinco dos meus projetos usam a mesma versão do Boost, não há necessidade de duplicar isso para cada projeto. Isto é especialmente verdade para as complexas árvores de dependência das quais você fala.

Com uma pasta lib, você gerencia pacotes apenas para esse projeto, enquanto um gerenciador de pacotes permite fazer isso em todo o ambiente de desenvolvimento com uma única ferramenta.

Athos vk
fonte
Não é tão fácil ter um agente de construção configurado para instalar um gerenciador de pacotes durante uma construção, restaurar dependências e assim por diante. Nada é necessário com uma pasta lib.
Ignacio Soler Garcia
4
Eu acho que depende de qual idioma você está usando. Em idiomas como Ruby ou Rust, o gerenciamento de pacotes é tão bem integrado que usá-lo é totalmente trivial.
Sean Burton
Bem, eu omiti isso de propósito para ter comentários mais amplos, mas estou falando especificamente sobre a nuvem NuGet, C # e VSTS.
Ignacio Soler Garcia
4
@ Ignacio Qualquer que seja o sistema de construção que você esteja usando, que não torne absolutamente trivial a restauração do NuGets, deve ser imediatamente descartado. Felizmente, o VSTS torna isso o mais fácil possível ( documentação ): há uma tarefa de restauração do NuGet que você aponta para o arquivo da solução e diz quais fontes o NuGet usar - para um projeto simples, o simples uso de sua aplicação nuget.org(o modelo padrão deve já esteja configurado dessa maneira).
Voo 12/06
3
@Ben RVM não é um gerenciador de pacotes. O gerenciador de pacotes do Ruby é o RubyGems. RVM gere versões do próprio Ruby, e por isso rbenv é melhor ...
Sean Burton
5

É a diferença entre usar apenas as bibliotecas (diretório lib) e usá-las, mantendo as meta-informações (gerenciador de pacotes) . Essa metinformação diz respeito a números de versão, dependências (transitivas) entre bibliotecas e outras.

As discussões sobre DLL hell, compatibilidade de bibliotecas, sistema de módulos java, OSGi e outros devem ser pelo menos suficientes para convencer alguns de que vale a pena ter alguma forma de gerenciamento de dependências.

  • A versão da biblioteca e os problemas de dependência podem ser uma perda de tempo.

Também há o benefício de um repositório compartilhado (local), portanto, vários projetos não precisam manter cópias de bibliotecas importadas. Se alguém tem um projeto com 20 submódulos, alguns desses módulos possuem 40 dependências ímpares.

  • Mais estrutura
  • Mais recorte de bibliotecas
  • Nenhuma decisão humana ad-hoc sobre bibliotecas
Joop Eggen
fonte
3

Existem alguns casos em que uma pasta lib pode ser necessária, por exemplo, ao lidar com bibliotecas obsoletas (uma versão dela não é mais mantida / disponível), uma versão modificada localmente de uma biblioteca, ...

Mas, para todo o resto, é como o desenvolvedor assumindo o papel de gerenciador de pacotes:

  • O desenvolvedor precisará fazer o download das bibliotecas (requer internet)
  • O desenvolvedor precisará verificar manualmente se há versões mais recentes
  • ...

E IMHO, é menos conhecimento necessário, porque você precisa aprender sobre o uso da ferramenta externa, mas menos sobre as bibliotecas (ou seja, dependências).

FranMowinckel
fonte
4
Mesmo para bibliotecas obsoletas ou modificadas, todos os gerenciadores de pacotes que eu vi até agora oferecem a opção de fazer upload de dependências locais no seu repositório local. Mas, ok, é aí que você perde parte da experiência "simplesmente funciona automaticamente".
Hulk
@Hulk Se for uma biblioteca de código aberto, você pode (e deve, provavelmente) apenas publicar sua versão e torná-la visível para o gerenciador de pacotes. Empurrando as modificações para os mantenedores ou trazendo sua própria bifurcação da biblioteca.
leftaroundabout
Se você modificou uma biblioteca cujo mantenedor não responde ao patch de e-mail, torna-se um problema descobrir como configurar o gerenciador de pacotes para que outros pacotes que dependem da biblioteca também possam ser satisfeitos com a sua biblioteca modificada.
Damian Yerrick
1

Há outro problema não coberto por outras perguntas: compartilhar deps.

Digamos que você tenha dois pacotes criando a mesma biblioteca. Na melhor das hipóteses, não haverá nenhum conflito, mas o mesmo espaço HDD / SSD será usado duas vezes. Na pior das hipóteses, haverá vários conflitos, como versões.

Se você usar o gerenciador de pacotes, ele instalará a biblioteca apenas uma vez (por versão) e já fornecerá o caminho para ela.

PS: é claro, você precisa de vínculo dinâmico (ou função semelhante no seu idioma) para obter esse profissional.

val
fonte
-5

Um dos principais motivos pelos quais as bibliotecas compartilhadas foram consideradas um item de progresso nos sistemas Unix e Windows da década de 90 foi como eles poderiam diminuir o uso de RAM quando vários programas usando o mesmo conjunto de bibliotecas foram carregados. O espaço do código só precisa ser alocado ONCE por biblioteca e versão exatas dessa biblioteca , o único uso de memória por instância restante é para variáveis ​​estáticas.

Muitos sistemas operacionais implementam bibliotecas compartilhadas de uma maneira que depende de mecanismos como o unix mmap () api - o que implica que uma biblioteca não apenas precisará ter exatamente a mesma versão, mas, na verdade, o mesmo arquivo. É simplesmente impossível tirar o máximo proveito de um programa que envia seu próprio conjunto de bibliotecas.

Dado que a memória é muito mais barata e as versões de bibliotecas precisavam de mais diversidade do que nos anos 90, esse argumento não tem tanto peso atualmente.

rackandboneman
fonte
4
Esta pergunta não fala sobre bibliotecas compartilhadas, mas dependências em uma pasta da biblioteca.
Ignacio Soler Garcia
11
Isso não responder do OP questão
esoterik