Eu gosto de Makefiles

 (switowski.com)
1 pontos por GN⁺ 2024-09-22 | 2 comentários | Compartilhar no WhatsApp

  • Eu gosto de Makefiles. Faz mais de 10 anos desde a primeira vez que usei um. Mesmo naquela época, já parecia uma tecnologia antiga. Com o passar do tempo, novas ferramentas de build surgiram e desapareceram, mas o Makefile continuou sendo usado. Fui me acostumando com ele ao participar de projetos e, em algum momento, passei a gostar dele. Hoje, é a primeira ferramenta de automação que uso ao começar um novo projeto.

  • O motivo de eu gostar de Makefiles é que eles seguem uma convenção informal de implementar o mesmo conjunto de comandos. Quando encontro um projeto novo e ele tem um arquivo Makefile, eu executo make ou make build, depois make install, e o projeto é compilado e configurado. Ou então consigo descobrir informações sobre etapas adicionais.

  • Tento aplicar a mesma convenção nos meus próprios projetos. Se eu abrir a pasta de um projeto antigo e executar make dev, ele realiza todas as etapas necessárias para compilar o projeto e iniciar o servidor de desenvolvimento. Como já usei várias tecnologias diferentes, cada uma tinha comandos distintos. Com um Makefile, fica fácil gerenciar até projetos que ficaram meses ou anos sem manutenção.

  • Makefiles são simples. Eu não uso condicionais, flags ou outros recursos complexos. A maioria das tarefas é composta por um ou mais comandos de shell. Eu até poderia escrever um script bash com algumas funções, mas um Makefile é mais fácil e rápido de escrever.

  • A maioria dos projetos pessoais inclui tarefas comuns como estas:

    • dev: iniciar o servidor de desenvolvimento
    • build: compilar o projeto (se houver uma etapa de build necessária)
    • deploy: fazer o deploy/publicar o projeto

  • Este blog tem um Makefile simples com um único target:

    dev:  
  npm run dev

  • Em projetos mais complexos, uso Makefiles como este:

    # Executar servidor de desenvolvimento  
dev:  
  bundle exec jekyll serve --unpublished -w --config _config.yml,_config-dev.yml --livereload  

# Compilar assets  
build:  
  npm run gulp build  

# Observar pastas específicas e processar assets  
watch:  
  npm run gulp watch -- --wip  

# Compilar o site localmente, criptografar e fazer deploy no servidor da Netlify  
deploy:  
  JEKYLL_ENV=production bundle exec jekyll build; \  
  make encrypt; \  
  netlify deploy --prod  

# Criptografar a pasta "_site"  
encrypt:  
  npx staticrypt _site/*.html -r -d _site

  • No exemplo acima, estou ignorando a existência de targets phony. Se houver um arquivo chamado dev, build, watch, deploy ou encrypt, o Makefile pode não funcionar como esperado.

  • O GNU Make é extremamente comum. No Linux, é bem provável que já esteja instalado. Também não me lembro de tê-lo instalado explicitamente no meu MacBook. Provavelmente veio junto com outras ferramentas. O Make é simples e tem menos dependências adicionais do que outras ferramentas de build. Isso pode ser útil em ambientes restritos. Há uma grande chance de o Make já estar disponível. Se não estiver, ainda dá para executar manualmente no shell os comandos do Makefile.

  • Isso não significa que eu seja contra outras ferramentas de build. Acho interessante quando descubro uma ferramenta nova. Mas ainda uso o Make para gerenciar várias ferramentas diferentes.

Resumo do GN⁺

  • O Makefile facilita o gerenciamento ao fornecer um conjunto consistente de comandos em vários tipos de projeto.
  • Com sintaxe simples e poucas dependências, ele também pode ser útil em ambientes restritos.
  • Pode ser usado junto com várias ferramentas de build, o que lhe dá bastante flexibilidade.
  • Ferramentas com funções parecidas incluem CMake, Ninja e Gradle.

Leituras relacionadas

2 comentários

 
kayws426 2024-09-22

Se o makefile não define dependências, substituí-lo por um justfile oferece uma usabilidade melhor.
 
GN⁺ 2024-09-22
Comentários do Hacker News

  • Incentivo ao uso de Make

    • Opinião de que não se deve desanimar por usar Make “do jeito errado”
    • A simplicidade é a vantagem do Make, e em projetos pequenos isso não costuma ser um grande problema
    • Na maioria dos casos, não é preciso se preocupar com a forma correta, e só se adiciona a complexidade necessária

  • Problemas dos Makefiles

    • Makefiles são menos ruins do que outros sistemas de build, mas ainda têm muitos problemas
    • Principais problemas dos sistemas de build:
      • Básicos demais: em projetos complexos, isso gera confusão
      • Complexos demais: exigem conhecimento prévio e manutenção excessivos
      • Falta de biblioteca padrão: é preciso definir tudo manualmente
      • Limitados demais: quando as necessidades mudam, é preciso migrar para outro sistema
      • Magia demais: característica de sistemas mal projetados
      • Sintaxe críptica ou inconsistente

  • Vantagens do Make

    • Opinião de quem gosta de Make
    • Make é um DSL simples, um conjunto de comandos para transformar arquivos
    • Também daria para fazer isso com Bash ou outro shell, mas Make é mais simples

  • Uso de targets PHONY

    • Não usa rastreamento de dependências baseado em mtime
    • É preciso definir os targets como PHONY
    • Recentemente, migrou para just e justfiles para usar algo mais simples

  • Debate acalorado sobre Make

    • Make provoca discussões como a guerra vi-vs-emacs
    • É inteligente usar Makefile como driver de alto nível do sistema de build
    • Mesmo usando outras ferramentas de build, dá para padronizar com Makefile

  • Vários usos do Make

    • Usa Make para automatizar várias tarefas
    • Usa Makefile para build e deploy de site pessoal
    • Chama Make por meio de Git push e Git hook
    • Usa Makefile para upload e gerenciamento de arquivos PDF

  • Limites e alternativas ao Make

    • Make é aceitável como executor de tarefas, mas há alternativas melhores
    • Make/Makefiles não são padronizados
    • Não resolvem dependências, exigindo scripts de configure
    • Usa mtime para verificar se a entrada está atualizada, mas isso pode causar problemas
    • Foi projetado segundo a filosofia Unix, mas tem limitações para sistemas de build modernos

  • Migração para Justfiles

    • Migrou para Justfiles para evitar a complexidade dos Makefiles

  • Uso simples de Makefile

    • Opinião favorável ao uso simples de Makefile
    • Dá para compartilhar sem aprender tudo perfeitamente
    • Relato de experiência em que o pipeline do GitLab CI substituiu o Makefile