Resposta curta: porque make
não é bom. Mesmo na frente C, você vê muitas alternativas surgindo.
Resposta longa: make
possui várias falhas que dificilmente são adequadas para compilar C e inadequadas para compilar Java. Você pode forçá-lo a compilar Java, se desejar, mas espere encontrar problemas, alguns dos quais não têm uma solução ou solução alternativa adequada. Aqui estão alguns:
Resolução de dependência
make
espera inerentemente que os arquivos tenham uma dependência semelhante a uma árvore, na qual um arquivo é o resultado da criação de vários outros. Isso já sai pela culatra em C ao lidar com arquivos de cabeçalho. make
requer que um make
arquivo de inclusão específico seja gerado para representar a dependência de um arquivo C em seus arquivos de cabeçalho; portanto, uma alteração no último faria com que o anterior fosse reconstruído. No entanto, como o arquivo C em si não é recriado (apenas reconstruído), o make geralmente requer a especificação do destino como .PHONY
. Felizmente, o GCC suporta a geração desses arquivos automaticamente.
Em Java, a dependência pode ser circular e não há ferramenta para gerar automaticamente dependências de classe no make
formato. ant
Em Depend
vez disso, a tarefa de pode ler o arquivo de classe diretamente, determinar quais classes ele importa e excluir o arquivo de classe se alguma delas estiver desatualizada. Sem isso, qualquer dependência não trivial pode resultar em você ser forçado a usar compilações limpas repetidas, removendo qualquer vantagem de usar uma ferramenta de compilação.
Espaços em nomes de arquivos
Embora nem Java nem C incentivem o uso de espaços em seus nomes de arquivos de código-fonte, make
isso pode ser um problema, mesmo que os espaços estejam no caminho do arquivo. Considere, por exemplo, se seu código-fonte existe em C:\My Documents\My Code\program\src
. Isso seria suficiente para quebrar make
. Isso ocorre porque make
trata os nomes de arquivos como strings. ant
trata os caminhos como objetos especiais.
Verificando arquivos para compilação
make
requer definir explicitamente quais arquivos devem ser criados para cada destino. ant
permite especificar uma pasta que deve ser verificada automaticamente em busca de arquivos de origem. Pode parecer uma conveniência menor, mas considere que em Java cada nova classe requer um novo arquivo. Adicionar arquivos ao projeto pode se tornar um grande aborrecimento rápido.
E o maior problema com make
:
make depende do POSIX
O lema de Java é "compilar uma vez executado em qualquer lugar". Mas restringir essa compilação a sistemas baseados em POSIX, nos quais o suporte a Java é realmente o pior, não é a intenção.
As regras de compilação make
são essencialmente pequenos bash
scripts. Mesmo que exista uma porta make
para o Windows, para que funcione corretamente, ela deve ser empacotada com uma porta de bash
, que inclui uma camada de emulação POSIX para o sistema de arquivos.
Isso vem em duas variedades:
MSYS
que tenta limitar a conversão POSIX a caminhos de arquivo e, portanto, pode ter dicas desagradáveis ao executar ferramentas externas não criadas especialmente para ela.
cygwin
que fornece uma emulação completa do POSIX. Os programas resultantes, no entanto, tendem a ainda confiar nessa camada de emulação.
Por esse motivo, no Windows, a ferramenta de construção padrão nem sequer é make
, mas sim MSBuild
, que também é uma ferramenta baseada em XML, mais próxima em princípio ant
.
Por outro lado, ant
é construído em Java, pode ser executado em qualquer lugar e contém ferramentas internas, chamadas "tarefas", para manipular arquivos e executar comandos de maneira independente da plataforma. É suficientemente versátil que você pode ter mais facilidade para criar um programa C no Windows usando do ant
que usando make
.
E um último menor:
Mesmo programas em C não usam make nativamente
Você pode não perceber isso inicialmente, mas os programas C geralmente não são enviados com um Makefile
. Eles são enviados com um CMakeLists.txt
, ou um bash
script de configuração, que gera o real Makefile
. Por outro lado, a fonte de um programa Java construído usando ant
é fornecida com um ant
script pré-construído. A Makefile
é um produto de outras ferramentas - é quanto make
é inadequado ser uma ferramenta de construção por si só. ant
é independente e lida com tudo o que você precisa para seu processo de construção Java, sem nenhum requisito ou dependência adicional.
Quando você executa ant
em qualquer plataforma, ele simplesmente funciona (tm). Você não pode entender isso make
. É incrivelmente dependente de plataforma e configuração.
make
. E ter um makefile que só funciona em um sistema não é muito bom para uma linguagem de plataforma cruzada.