Oi turma, tudo bom?
Aqui tudo…
Hoje, nessa coisa aqui, vamos falar de uma coisa que me chama a atenção toda vez que aparece um daqueles avisos: “Baixe nosso aplicativo. É pequeno, tem só 300 MB”.
Só.
Eu sou do tempo em que um programa de 80 MB fazia a gente pensar duas vezes antes de instalar. Primeiro vinha a pergunta sobre o espaço no HD. Depois, dependendo de como ele chegaria até o computador, vinha outra: quanto tempo vou levar para baixar essa criatura?
Hoje, um aplicativo aparentemente simples pode passar dos 80 MB só no executável. O pacote completo vai para 200, 300 MB ou mais. E, quando a gente abre, encontra uma janela, uns campos e meia dúzia de botões.
Aí bate aquela curiosidade: o que veio junto? O programa ou a mudança inteira do desenvolvedor? aaa…
Vamos entender de onde sai esse tamanho, quais escolhas fazem sentido e em que ponto a facilidade para desenvolver começa a custar caro para quem usa.
Neste post
- Quando baixar 300 MB era um compromisso para o fim de semana
- Download, executável, instalação e memória: quatro medidas diferentes
- O “mini-navegador” que tem pouca coisa de mini
- O programa trouxe as bibliotecas. E as bibliotecas trouxeram companhia
- Python, Go e outras linguagens: por que o executável cresce?
- A comodidade tem vantagens. A conta também chega
- O que dá para fazer para diminuir essa bagagem?
- Ainda vale a pena se preocupar com isso?
- Fontes e leituras complementares
Quando baixar 300 MB era um compromisso para o fim de semana
Quem pegou a conexão discada sabe que baixar um programa podia exigir planejamento. A gente calculava horário, deixava o computador trabalhando e torcia pela estabilidade da linha.
Um arquivo de 300 MB podia render seis noites de download, ou um fim de semana inteiro se a brincadeira começasse no sábado. Dependia da velocidade, das interrupções e de quanto tempo a linha podia ficar ocupada.
Para dar uma ideia: numa transferência constante de 4 KB por segundo, 300 MB levariam aproximadamente 20 horas e 50 minutos. É uma conta ilustrativa, usando unidades decimais e sem acrescentar pausas. Dividindo em seis noites, seriam quase três horas e meia de transferência por noite.
E bastava uma queda, um servidor que não aceitasse continuar de onde parou ou algum outro imprevisto para o calendário ganhar mais um capítulo.
Os famosos modems de 56k tinham, no padrão V.90, limite nominal de download de até 56 mil bits por segundo. Bits, turma: isso corresponde a 7 mil bytes por segundo antes das perdas e sobrecargas. A velocidade anunciada não era uma promessa de 56 KB por segundo. [10]
Hoje, para muita gente com banda larga e espaço sobrando, 300 MB passam quase despercebidos. Mas quem viveu aquela época ainda olha para esse “só” com uma certa desconfiança, aaa…
Download, executável, instalação e memória: quatro medidas diferentes
Antes de apontar o dedo para qualquer programa, vale separar as medidas.
- Tamanho do download: quanto precisa ser transferido. O instalador pode estar compactado ou pode baixar componentes durante a instalação.
- Tamanho do executável: o tamanho daquele arquivo que iniciamos. Ele pode concentrar muitos componentes ou ser apenas a entrada para uma pasta cheia de arquivos.
- Espaço instalado: quanto o conjunto ocupa depois de instalado ou extraído. Dados, cache e atualizações podem aumentar essa conta com o uso.
- Consumo de memória: quanto o programa utiliza enquanto está funcionando. Isso precisa ser medido durante a execução.
Portanto, um executável de 80 MB não significa automaticamente 80 MB de memória ocupada. E um executável de 500 KB pode depender de componentes muito maiores que já estejam no computador.
A comparação justa considera o conjunto necessário para funcionar. Aquele instalador de 2 MB que busca mais 300 MB pela internet também merece entrar na conversa.
O “mini-navegador” que tem pouca coisa de mini
Um dos exemplos mais conhecidos é o Electron, usado para criar programas de desktop com HTML, CSS e JavaScript. Ele leva Chromium e Node.js junto com o aplicativo. Chromium fornece a infraestrutura de navegação e apresentação da interface; Node.js permite executar JavaScript com recursos para trabalhar fora da página. [1]
Isso permite reaproveitar bastante código entre Windows, Linux e macOS. A equipe também controla a versão dos componentes que acompanha seu produto, em vez de depender inteiramente do que estiver instalado na máquina do usuário.
A contrapartida é o volume. A própria documentação do Electron reconhece o custo de espaço e cita aplicativos compactados geralmente na faixa de 80 a 100 MB. São referências do projeto, não limites fixos: dependências e conteúdo de cada aplicativo mudam bastante o resultado. [1]
O apelido “mini-navegador” pode enganar. A janela pode ser pequena, mas a infraestrutura por baixo continua sofisticada.
E existe uma diferença entre um aplicativo web que abrimos no navegador já instalado e um programa de desktop que distribui sua própria infraestrutura web. Não dá para colocar todo webapp na mesma conta.
Quando vários aplicativos levam cópias próprias desses componentes, a repetição aparece no disco. Cada um chegou com sua mala. O problema é que algumas malas parecem mudança de apartamento.
O programa trouxe as bibliotecas. E as bibliotecas trouxeram companhia
Mesmo sem navegador embutido, o pacote pode crescer bastante.
Uma biblioteca é um conjunto de recursos pronto para ser aproveitado por outros programas. Pode cuidar da interface, de imagens, de áudio, de banco de dados e de muitas outras tarefas. Isso poupa trabalho e permite usar implementações já testadas.
Só que uma biblioteca pode depender de outras. O desenvolvedor escolhe um componente para resolver determinada necessidade e, com ele, chega uma cadeia de dependências.
A documentação de desempenho do Electron traz um caso curioso: uma verificação de conexão com a internet acabava puxando dependências que incluíam um arquivo com mais de 100 mil linhas de informações sobre portas de rede. Naquele caso, o próprio Chromium passou a oferecer uma solução que dispensava o módulo. É um exemplo bem concreto de como uma necessidade pequena pode carregar uma bagagem desproporcional. [9]
Também entram nessa conta imagens, fontes, traduções, sons, modelos de inteligência artificial e outros recursos. Cada um pode ter sua utilidade. O trabalho de revisão consiste em descobrir quais realmente precisam acompanhar aquela versão do programa.
Reaproveitar bibliotecas é uma boa prática. Conferir o que elas acrescentam ao produto também precisa fazer parte do serviço.
Python, Go e outras linguagens: por que o executável cresce?
Os motivos variam conforme a linguagem, as bibliotecas e a forma de distribuição.
No Python, uma ferramenta muito usada é o PyInstaller. Ele reúne o programa, o interpretador Python e os módulos e bibliotecas identificados como necessários. Assim, a pessoa pode executar o aplicativo sem instalar Python separadamente. Bibliotecas de interface, processamento de imagens e outras funções acrescentam seu próprio volume. [6]
No modo de arquivo único, boa parte dessa estrutura fica dentro do executável. Ao iniciar, arquivos de suporte são extraídos para uma pasta temporária, o que também pode aumentar o tempo de abertura. O “arquivo único” continua levando um conjunto de componentes dentro dele. O PyInstaller empacota o ambiente; esse processo não equivale a transformar todo o aplicativo em código nativo como faz um compilador de Go. [6]
No Go, também conhecido como Golang, o programa é compilado para código nativo. A ferramenta padrão inclui no binário o runtime da linguagem, responsável por recursos como gerenciamento de memória e execução concorrente, além do código necessário das dependências. Informações de tipos e de depuração também ocupam espaço. [7]
A própria FAQ do Go situa um exemplo simples de “Olá, mundo” na ordem de poucos megabytes. Portanto, 80 MB não é um tamanho mínimo da linguagem. Um executável desse porte pede uma análise das bibliotecas, dos arquivos incorporados e das opções de compilação daquele projeto. [7]
No .NET, usado por linguagens como C#, há escolhas de distribuição. Uma publicação pode depender de um runtime instalado no computador ou levar sua própria cópia. A segunda facilita controlar o ambiente de execução, mas aumenta o pacote. Uma comparação entre esses modelos precisa considerar também o runtime compartilhado que o primeiro exige. [2]
Ou seja: saber apenas a linguagem em que o programa foi escrito explica uma parte da história. As escolhas de bibliotecas e de empacotamento completam o resto.
A comodidade tem vantagens. A conta também chega
Levar as dependências junto ajuda a evitar aquela situação clássica: o programa funciona no computador do desenvolvedor e, quando chega ao usuário, falta uma biblioteca, sobra uma versão incompatível e começa a peregrinação.
Uma equipe pequena também consegue entregar seu trabalho para mais sistemas sem manter três interfaces inteiramente diferentes. Isso tem valor, inclusive para projetos gratuitos e independentes.
A crítica começa quando o custo para quem usa deixa de ser considerado. “O computador de hoje aguenta” vira uma desculpa confortável para não medir, não revisar e não perguntar se a ferramenta escolhida combina com a tarefa.
Um editor de vídeo, com recursos de processamento e formatos de mídia, tem necessidades diferentes de um utilitário que altera o nome de alguns arquivos. A exigência de recursos deveria acompanhar o trabalho entregue.
E a soma importa. Um programa ocupa 300 MB, outro também, mais alguns repetem componentes, e ainda chegam dados, caches e atualizações. Num computador com pouco armazenamento, ou numa conexão limitada, a conta fica bem mais visível.
Para quem desenvolve, economizar tempo faz sentido. Para quem usa, economizar espaço, transferência e espera também faz.
O que dá para fazer para diminuir essa bagagem?
1. Escolher a estrutura conforme a tarefa. Um utilitário pequeno merece considerar os controles e serviços que o sistema já oferece. Projetos maiores podem justificar estruturas mais completas. Essa escolha fica melhor quando o consumo de recursos entra nos critérios desde o começo.
2. Aproveitar componentes compartilhados quando isso for adequado. O WebView2, no Windows, tem um modelo Evergreen em que vários aplicativos compartilham o runtime, que recebe atualizações. O Tauri também utiliza a infraestrutura de WebView disponível na plataforma. Isso pode reduzir bastante o pacote de cada aplicativo, embora a dependência continue existindo e possa precisar ser instalada. Há diferenças entre plataformas que exigem testes. [3] [8]
3. Rever as dependências. Vale examinar o tamanho, o encadeamento e o trabalho executado por cada biblioteca. Às vezes existe uma alternativa menor; às vezes o próprio sistema já fornece o recurso. Essa análise precisa preservar a qualidade da implementação. [9]
4. Usar as opções de redução compatíveis com o projeto. Ferramentas podem remover código não utilizado e informações de depuração do arquivo distribuído. O Go documenta a retirada de informações de depuração, e o .NET oferece redução de aplicações compatíveis. É preciso testar: recursos carregados dinamicamente, por exemplo, podem dificultar a identificação do que é dispensável. [7] [2] [4]
5. Separar recursos realmente opcionais. Pacotes de voz, modelos grandes e funções adicionais podem ser oferecidos à parte, com informação clara sobre o tamanho. A instalação básica precisa continuar útil, e quem precisa trabalhar sem internet deve conseguir obter o conjunto completo.
6. Evitar transferir tudo de novo a cada ajuste. Quando a estrutura permitir, atualizações por componentes ou pelas diferenças entre versões podem reduzir o download. O PyInstaller, por exemplo, descreve situações em que uma distribuição em pasta permite atualizar apenas o executável, desde que as dependências permaneçam as mesmas. [6]
7. Considerar o navegador já instalado. Para algumas tarefas, um aplicativo web ou uma PWA atende bem e aproveita essa infraestrutura. PWAs também podem oferecer recursos offline quando desenvolvidos para isso. Continuam existindo arquivos locais e cache, e a adequação depende das funções necessárias. [5]
8. Medir em condições próximas das de quem usa. Vale conferir o download total, o espaço ocupado, o tempo de abertura e o funcionamento com pouca memória disponível. Compactar o instalador pode diminuir a transferência, mas o comportamento do programa aberto precisa de uma avaliação própria.
E, falando de algo que me interessa diretamente: todos esses testes precisam incluir teclado e leitor de telas. Uma interface leve que deixa parte das pessoas sem conseguir usar o programa continua precisando de trabalho.
Ainda vale a pena se preocupar com isso?
Vale, mesmo que hoje 300 MB sejam tranquilos para muita gente.
Os programas atuais oferecem recursos, compatibilidade e possibilidades que a gente nem imaginava na época dos disquetes e da conexão discada. Parte do crescimento acompanha essas capacidades. Outra parte merece uma boa revisão.
Também seria injusto olhar apenas para o executável antigo e esquecer as bibliotecas e os componentes do sistema de que ele dependia. O esforço deve ser comparar o conjunto e o resultado entregue.
O que eu gostaria de ver com mais frequência é cuidado com proporção. Se uma escolha acrescenta dezenas ou centenas de megabytes, que exista uma razão para ela, e que as alternativas tenham sido consideradas.
Continuo gostando de abrir um programa, fazer o que preciso e seguir a vida. Quanto menos tempo gasto esperando pela ferramenta, mais tempo sobra para o trabalho.
E continuo achando curioso ver um “programinha” de 300 MB para uma tarefa pequena. Meu lado que veio da conexão discada já começa a calcular: “Se eu começar no sábado, será que termina até segunda?” aaa…
Um abraço e até a próxima!
Fernando.
Fontes e leituras complementares
Primeiro, as páginas disponíveis em português. Algumas documentações têm trechos ainda em inglês. Em seguida estão as fontes em inglês, com opção de tradução automática.
- Electron — Por que Electron. Explica a distribuição de Chromium e Node.js, os benefícios e o custo de espaço. Ler a documentação.
- Microsoft Learn — Visão geral da publicação de aplicativos .NET. Explica publicação dependente de runtime, autossuficiente e outras opções. Ler a documentação.
- Microsoft Learn — Evergreen versus versão fixa do WebView2 Runtime. Apresenta as diferenças de distribuição e o compartilhamento do runtime. Ler a documentação.
- Microsoft Learn — Cortar aplicativos autossuficientes. Explica redução de tamanho e limitações de compatibilidade. Ler a documentação.
- MDN — Progressive Web Apps. Apresenta PWAs, instalação e funcionamento offline. Ler a documentação.
- PyInstaller — What PyInstaller Does and How It Does It. Explica o interpretador e as dependências incluídos, o arquivo único e a distribuição em pasta. Original em inglês | Tradução automática para português.
- Go — Frequently Asked Questions. Consulte “Why is my trivial program such a large binary?” para a explicação sobre runtime, tamanho e depuração. Original em inglês | Tradução automática para português.
- Tauri — Tauri Architecture. Explica a arquitetura e o uso da WebView da plataforma. Original em inglês | Tradução automática para português.
- Electron — Performance. Inclui recomendações sobre dependências, medições e o exemplo do módulo de verificação de conexão. Original em inglês | Tradução automática para português.
- UIT — Recomendação V.90. Especifica os limites nominais de transmissão dos modems desse padrão. Os tempos de download apresentados no texto são cálculos ilustrativos. Original em inglês | Tradução automática para português.