Pourquoi personne n'utilise faire pour Java?

Question

À peu près tous les projets Java que j'ai vu soit des utilisations Maven ou Ant. Ils sont beaux outils et je pense à peu près tout projet peut les utiliser. Mais ce qu'il est advenu faire ? Il est utilisé pour une variété de projets non-Java et peut facilement gérer Java. Bien sûr, vous devez télécharger make.exe si vous utilisez Windows, mais Ant et Maven aussi ne viennent pas avec le JDK.

Y at-il une faille fondamentale avec make lorsqu'il est utilisé avec Java? Est-ce juste parce que Ant et Maven sont écrits en Java?

Answer 1

La question fondamentale avec Make et Java est que faire des œuvres sur la prémisse que vous avez spécifier une dépendance, et une règle pour résoudre cette dépendance.

Avec C de base, qui généralement « pour convertir un fichier main.c dans un fichier main.o, exécutez "cc main.c".

Vous pouvez le faire en Java, mais vous apprendrez rapidement quelque chose.

La plupart du temps que le compilateur javac est lent à démarrer.

La différence entre:

javac Main.java
javac This.java
javac That.java
javac Other.java

et

javac Main.java This.java That.java Other.java

est nuit et jour.

avec des centaines qui aggrave-t-de classes, et il devient tout simplement intenable.

Ensuite, vous moissonneuse-batteuse avec le fait que Java a tendance à être organisé en tant que groupes de fichiers dans les répertoires, contre C et d'autres qui tendent vers une structure plus plate. Faire ne pas offrir une aide directe à travailler avec les hiérarchies de fichiers.

Faire aussi est pas très bon pour déterminer quels fichiers sont périmés, à un niveau de collecte.

Avec Ant, il traversera en somme, puis les compiler tous les fichiers qui sont à jour en une seule fois. Faire appellera simplement le compilateur Java sur chaque fichier. Ayant fait pas faire cela nécessite un outillage assez externe pour montrer vraiment est de ne pas tout à fait à la tâche.

Voilà pourquoi des alternatives comme Ant et Maven se levèrent.

Answer 2

Le programme de make vénérable poignées langues compilées séparément comme C et C ++ assez bien. Vous compilez un module, il utilise #include pour tirer dans le texte d'autres comprennent des fichiers, et écrit un seul fichier d'objet en sortie. Le compilateur est très un-à-un-temps système, avec une étape de liaison séparés pour lier les fichiers objets dans un binaire exécutable.

Cependant, en Java, le compilateur doit en fait compilation d'autres classes que vous importez avec import. Bien qu'il soit possible d'écrire quelque chose qui a généré toutes les dépendances nécessaires à partir du code source Java, de sorte que make construirait classes dans l'ordre un à la fois, ce ne serait toujours pas traiter les cas comme des dépendances circulaires.

Le compilateur Java peut aussi être plus efficace en mettant en cache les résultats compilés d'autres classes lors de la compilation des classes supplémentaires qui dépendent des résultats de ceux qui sont déjà compilés. Ce type d'évaluation de la dépendance automatique n'est pas vraiment possible avec make seul.

Answer 3

La question est basée sur une hypothèse erronée: un nombre non négligeable de développeurs faire utiliser make. Voir Java: Ant Construits Outils par rapport à Maven . Quant à savoir pourquoi un développeur ne serait pas utiliser make: de nombreux développeurs ont soit jamais utilisé make, ou utilisé et haï avec un feu qui brûle plus d'un millier de soleils. À ce titre, ils utilisent d'autres outils.

Answer 4

En fait, faire peut gérer la recompilation dans une commande de tous les fichiers Java obsolètes. Modifiez la première ligne si vous ne voulez pas compiler tous les fichiers dans le répertoire ou si vous voulez un ordre spécifique ...

JAVA_FILES:=$(wildcard *.java)
#
# the rest is independent of the directory
#
JAVA_CLASSES:=$(patsubst %.java,%.class,$(JAVA_FILES))

.PHONY: classes
LIST:=

classes: $(JAVA_CLASSES)
        if [ ! -z "$(LIST)" ] ; then \
                javac $(LIST) ; \
        fi

$(JAVA_CLASSES) : %.class : %.java
        $(eval LIST+=$$<)

Answer 5

Toutes les autres réponses sur les mérites techniques de chacun sont vraies. Ant et Maven peuvent être mieux adaptés à Java que faire, ou comme le souligne Hank Gay, ils ne peuvent pas:)

Cependant, vous avez demandé s'il importe que Ant et Maven sont écrits en Java. Bien que sur StackOverflow nous ne considérons pas ces pensées (fermé! Sans programmation liées! Etc.), DE COURS QUI EST PARTIE DE LA CHOSE. Sur les rails, nous utilisons Rake, C dudes d'utilisation en font, et en Java, nous utilisons Ant et Maven. Il est vrai que les développeurs Ant ou Maven s'occuper le développeur Java peut-être mieux que d'autres, il y a aussi une autre question: qu'est-ce que vous écrivez dans des tâches Ant? Java. Si vous êtes un développeur Java, qui est un ajustement facile.

Alors oui, une partie est d'utiliser des outils écrits dans la langue que vous outillage.

Answer 6

Ant et Maven plus tard ont été conçus pour résoudre certains maux de tête causés par Make (tout en créant de nouvelles dans le processus) Il est juste l'évolution.

  

... Peu après, plusieurs projets Java open source réalisé que Ant pourrait résoudre les problèmes qu'ils avaient avec Makefile ....

De http://ant.apache.org/faq.html#history

Qu'ils résoudre quoi que ce soit ou tout simplement créer un format supplémentaire pour apprendre est un sujet subjectif. La vérité est que est à peu près l'histoire de chaque nouvelle invention: Le créateur dit qu'il résout beaucoup de problèmes et les utilisateurs d'origine que ce sont là des vertus.

Le principal avantage qu'il a, est la possibilité d'intégrer avec java.

Je suppose une histoire similaire serait avec rake par exemple.

Answer 7

L'un des principaux problèmes résolus par Maven (et Ivy activé configurations Ant) sur make est automatisé résolution de la dépendance et le téléchargement de vos pots de dépendance.

Answer 8

Je pense que l'explication la plus probable est que plusieurs facteurs découragent l'utilisation de faire au sein de la communauté Java dans une période critique (les fin des années 1990):

1. Parce que Java comprend plusieurs plates-formes, les programmeurs Java en général ne sont pas aussi habiles à outils Unix comme programmeurs étaient généralement confinés à un environnement Unix (par exemple, les programmeurs C et Perl). Notez que ceci est en général. Sans aucun doute, il y a et étaient doués programmeurs Java avec une compréhension profonde d'Unix.
2. Par conséquent, ils étaient moins aptes à faire et ne savaient pas comment utiliser efficacement faire.
3. Bien qu'il soit possible d'écrire un Makefile court et simple qui compile Java efficace, une attention particulière est nécessaire de le faire d'une manière indépendante de la plateforme.
4. Par conséquent, il y avait un appétit pour un outil de construction de plate-forme indépendante intrinsèquement.
5. Il est dans ce contexte que Ant et Maven plus tard ont été créés.

En bref, tout faire certainement peut être utilisé pour des projets Java, il y a eu un moment de l'occasion pour en faire l'outil de construction de facto Java. Ce moment est passé.

Answer 9

Faire des scripts ont tendance à être la plate-forme intrinsèquement dépendante. Java est censé être la plate-forme indépendante. Par conséquent, avoir un système de construction qui ne fonctionne que sur une plate-forme pour une Sourcebase multi-plateforme est kindof un problème.

Answer 10

À moins que je ne suis personne l'hypothèse n'est (mal) en utilisant make pour java est faux.

"Gestion de projets avec GNU Make" (disponible sous GFDL) contient un chapitre complet consacré à l'utilisation make avec des projets java.

Comme il contient une longue (et je l'espère juste) la liste des avantages et des inconvénients de l'utilisation faire à la place d'autres outils que vous voudrez peut-être jeter un oeil là-bas. (Voir: http://oreilly.com/catalog/make3/book/ )

Answer 11

Short answer: Because make isn't good. Even on the C front you see many alternatives popping up.

Long answer: make has several flaws that make it barely suitable for compiling C, and unsuitable at all for compiling Java. You can force it to compile Java, if you want, but expect running into issues, some of which do not have a suitable solution or workaround. Here are a few:

Dependency resolution

make inherently expects files to have a tree-like dependency on each other, in which one file is the output of building several others. This already backfires in C when dealing with header files. make requires a make-specific include file to be generated to represent the dependency of a C file on its header files, so a change to the latter would cause the prior to be rebuilt. However, since the C file itself isn't recreated (merely rebuilt), make often requires specifying the target as .PHONY. Fortunately, GCC supports generating those files automatically.

In Java, dependency can be circular, and there's no tool for auto-generating class dependencies in make format. ant's Depend task can, instead, read the class file directly, determine which classes it imports, and delete the class file if any of them are out of date. Without this, any non-trivial dependency may result in you being forced to use repeated clean builds, removing any advantage of using a build tool.

Spaces in filenames

While neither Java nor C encourage using spaces in your source code filenames, in make this can be problem even if the spaces are in the file path. Consider, for example, if your source code exists in C:\My Documents\My Code\program\src. This would be enough to break make. This is because make treats filenames as strings. ant treats paths as special objects.

Scanning files for build

make requires explicitly setting which files are to be built for each target. ant allows specifying a folder which is to be auto-scanned for source files. It may seem like a minor convenience, but consider that in Java each new class requires a new file. Adding files to the project can become a big hassle fast.

And the biggest problem with make:

make is POSIX-dependent

Java's motto is "compile once run everywhere". But restricting that compilation to POSIX-based systems, in which Java support is actually the worst, is not the intention.

Build rules in make are essentially small bash scripts. Even though there is a port of make to Windows, for it to work properly, it has to be bundled with a port of bash, which includes a POSIX emulation layer for the file system.

This comes in two varieties:

1. MSYS which tries to limit the POSIX translation to file paths, and can therefore have unpleasant gotchas when running external tools not made especially for it.

2. cygwin which provides a complete POSIX emulation. The resulting programs, however, tend to still rely on that emulation layer.

For that reason, on Windows, the standard build tool isn't even make at all, but rather MSBuild, which is also an XML-based tool, closer in principle to ant.

By contrast, ant is built in Java, can run everywhere, and contains internal tools, called "tasks", for manipulating files and executing commands in a platform-independent way. It's sufficiently versatile that you can actually have an easier time building a C program in Windows using ant than using make.

And one last minor one:

Even C programs don't use make natively

You may not initially notice this, but C programs generally aren't shipped with a Makefile. They are shipped with a CMakeLists.txt, or a bash configuration script, which generates the actual Makefile. By contrast, the source of a Java program built using ant is shipped with an ant script pre-built. A Makefile is a product of other tools - That's how much make is unsuitable to be a build tool on its own. ant is standalone, and deals with everything you need for your Java build process, without any additional requirements or dependencies.

When you run ant on any platform, it Just Works(tm). You can't get that with make. It's incredibly platform and configuration dependent.

Answer 12

Ant is an XML configuration oriented improvement over Makefiles and Maven is a dependency build tool improvement over Ant. Some projects use all three. I think the JDK projects used to use a mix of makefiles and ant.

Answer 13

One big reason is that both Ant and Maven (and most java targeted SCM, CI and IDE tools) are written in java by/for java developers. This makes it simpler to integrate into your development environment and allows other tools such as the IDE and CI servers to integrate portions of the ant/maven libraries within the build/deployment infrastructure.

Answer 14

Once upon a time I worked on a Java project that used gmake. My recollection is hazy but IIRC we had a hard time dealing with the package directory structure that javac expects. I also remember that building JAR files was a hassle unless you had something trivial.

Answer 15

ApacheAnt isn't anything like Make. Make is about describing dependencies between files, and how to build files. Ant is about dependencies between "tasks", and is really more of a way of gluing build scripts together.

it may helps you AntVsMake

Answer 16

Ant and Maven approach the build dependency graph and the management of it from a more 'modern' view... But as Oscar says, they created their own problems while attempting to address the old problems with make.

Answer 17

I've never used GNU Make for Java projects, but I used to use jmk. Sadly it hasn't been updated since 2002.

It had some Java-specific functionality but was small enough to include in your source tarball without significantly increasing its size.

Nowadays I just assume any Java developer I share code with has Ant installed.