Pourquoi Maven a-t-il une si mauvaise réputation? [fermé]

On parle beaucoup sur Internet de la façon dont Maven est mauvais. J'utilise certaines fonctionnalités de Maven depuis quelques années maintenant et l'avantage le plus important à mon avis est la gestion des dépendances.

La documentation Maven est loin d'être adéquate, mais généralement, lorsque j'ai besoin d'accomplir quelque chose, je le découvre une fois, puis cela fonctionne (par exemple, lorsque j'ai implémenté la signature des fichiers JAR). Je ne pense pas que Maven soit génial, mais cela résout certains problèmes qui sans cela seraient une véritable douleur.

Alors, pourquoi Maven a-t-il une si mauvaise réputation et à quels problèmes avec Maven puis-je m'attendre à l'avenir? Peut-être qu'il existe de bien meilleures alternatives que je ne connais pas? (Par exemple, je n'ai jamais regardé Ivy en détail.)

REMARQUE: il ne s'agit pas d'une tentative de provoquer un argument. C'est une tentative d'effacer le FUD.

J'ai examiné maven il y a environ six mois. Nous démarrions un nouveau projet et n'avions aucun héritage à soutenir. Cela dit:

• Maven est tout ou rien. Ou du moins pour autant que je puisse dire d'après la documentation. Vous ne pouvez pas facilement utiliser maven en remplacement de la fourmi et adopter progressivement des fonctionnalités plus avancées.
• Selon la documentation, Maven est un bonheur transcendantal qui réalise tous vos rêves les plus fous. Il vous suffit de méditer sur le manuel pendant 10 ans avant de devenir éclairé.
• Maven rend votre processus de construction dépendant de votre connexion réseau.
• Maven a des messages d'erreur inutiles. Comparez «La cible x n'existe pas dans le projet y» de fourmi avec «Tâche non valide 'run' de mvn: vous devez spécifier une phase de cycle de vie valide, ou un objectif au format plugin: goal ou pluginGroupId: pluginArtifactId: pluginVersion: goal» il suggère que je lance mvn avec -e pour plus d'informations, ce qui signifie qu'il affichera le même message, puis une trace de pile pour une BuildFailureException.

Une grande partie de mon aversion pour maven peut être expliquée par l'extrait suivant de Better Builds with Maven:

Quand quelqu'un veut savoir ce qu'est Maven, il demande généralement «Qu'est-ce que Maven exactement?», Et s'attend à une réponse courte et expressive. «Eh bien, c'est un outil de construction ou un cadre de script» Maven est plus de trois mots ennuyeux et sans intérêt. C'est une combinaison d'idées, de normes et de logiciels, et il est impossible de distiller la définition de Maven à des extraits sonores simplement digérés. Les idées révolutionnaires sont souvent difficiles à transmettre avec des mots.

Ma suggestion: si vous ne pouvez pas transmettre les idées avec des mots, vous ne devriez pas essayer d'écrire un livre sur le sujet, car je ne vais pas absorber les idées par télépathie.

• Il vous impose une structure rigide dès le départ.
• Il est basé sur XML, il est donc aussi difficile à lire que l'était ANT.
• Son rapport d'erreur est obscur et vous laisse bloqué lorsque les choses tournent mal.
• La documentation est médiocre.
• Cela rend les choses difficiles faciles et les choses simples difficiles.
• Il faut trop de temps pour maintenir un environnement de construction Maven, ce qui va à l'encontre de l'intérêt d'avoir un système de construction tout chantant.
• Il faut beaucoup de temps pour comprendre que vous avez trouvé un bogue dans maven et que vous n'avez pas configuré quelque chose de mal. Et les bugs existent, et dans des endroits surprenants.
• Il promet beaucoup mais vous trahit comme un amant beau et séduisant mais émotionnellement froid et manipulateur.

J'ai certainement râlé et gémi à propos de maven dans le passé. Mais maintenant, je ne serais pas sans ça. Je pense que les avantages l'emportent largement sur les problèmes. Principalement:

• Structure de projet standardisée.
  • Étant donné qu'un nouveau développeur rejoint un projet:
    • Lorsque vous dites que c'est un projet Maven, le développeur connaît la disposition du projet et comment créer et empaqueter le projet
    • Lorsque vous dites que c'est un projet Ant, le développeur devra attendre que vous expliquiez plus ou devra passer par le build.xml pour comprendre les choses.
  • Bien sûr, il est toujours possible d'imposer un standard à l'échelle de l'entreprise avec Ant, mais je pense que le plus souvent, vous réinventerez la roue proverbiale.
• Gestion des dépendances.
  • Non seulement avec des bibliothèques externes, mais aussi avec des bibliothèques / modules internes. Assurez-vous d'utiliser un serveur proxy de référentiel Maven tel que Nexus ou Artifactory .
  • Il est possible de faire une partie de cela avec Ivy . En fait, si vous n'avez besoin que d'une gestion des dépendances, vous feriez probablement mieux d'utiliser Ivy.
• Particulièrement au sein d'un projet. J'ai trouvé très utile d'éclater de petits sous-projets, et maven gère bien cela. C'est beaucoup plus difficile avec la fourmi.
• Gestion standardisée des artefacts (en particulier en association avec un nexus ou un artefact )
• Le plugin release est merveilleux.
• L'intégration Eclipse & NetBeans est assez bonne.
• L'intégration avec hudson est superbe. En particulier, les graphiques de tendance pour des choses comme les findbugs.
• Il est un point mineur, mais le fait que Maven Incorporations détails comme le numéro de version dans le pot ou la guerre ( et pas seulement dans le nom de fichier) par défaut est extrêmement utile.

Les inconvénients pour moi sont principalement:

• La ligne de commande n'est pas très utile. Cela m'a beaucoup découragé au début.
• Le format XML est très détaillé. Je peux voir pourquoi cela a été fait de cette façon, mais c'est toujours difficile à lire.
  • Cela dit, il a un XSD pour une édition facile dans un IDE.
• Il est difficile de se faire une idée au début. Des choses comme le cycle de vie, par exemple.
  • Le guide définitif de maven est cependant une bonne introduction.

Je crois sincèrement que cela vaut la peine de passer un peu de temps à connaître maven.

Mon expérience pratique de deux grands projets est que nous avons passé 1000 à 1500 heures pour chaque projet sur des problèmes liés à maven, à l'exclusion d'un effort de 500 heures pour passer de maven 1 à maven 2.

Depuis, je dois dire que je déteste absolument les maven. Je suis frustré quand j'y pense.

L'intégration Eclipse est horrible. (Nous avons eu des problèmes sans fin avec la génération de code par exemple, où eclipse s'est désynchronisée avec le code généré, et a nécessité une reconstruction complète, assez souvent. Le blâme est à la fois maven et eclipse, mais eclipse est plus utile que maven et disons emacs, donc l'éclipse reste et les maven doivent partir.)

Nous avions beaucoup de dépendances, et comme nous l'avons découvert, les erreurs de syntaxe sont en fait assez souvent commises dans des référentiels publics maven, ce qui peut ruiner des heures de votre temps précieux. Chaque semaine. La solution de contournement consiste à avoir un proxy ou un référentiel régi localement et cela a également pris un certain temps.

La structure du projet Mavens n'est pas vraiment adaptée au développement avec Eclipse, et le temps de construction dans eclipse augmente.

Un effet du problème de génération de code et de synchronisation, nous avons dû reconstruire à partir de scrach assez souvent, réduisant votre cycle de code / compilation / test à un cycle de compilation / websurf / sleep / die / code sans fin, vous renvoyant aux années 90 et Temps de compilation de 40 minutes.

La seule excuse pour maven est la résolution des dépendances, mais j'aimerais le faire de temps en temps, pas dans chaque build.

Pour résumer, maven est aussi loin que possible de KISS. Et aussi, les défenseurs ont tendance à être le type de personnes qui célèbrent davantage leur anniversaire lorsque leur âge est un nombre premier. N'hésitez pas à voter contre moi :-)

Maven est génial. La raison de sa réputation a à voir avec la courbe d'apprentissage abrupte, à mon avis. (ce que je suis enfin sur le point de surmonter)

La documentation est un peu difficile à parcourir, simplement parce que l'on a l'impression qu'il y a beaucoup de texte et de nouvelles choses à comprendre avant de commencer à avoir un sens. Je dis que le temps est tout ce qu'il faut pour que Maven soit plus largement salué.

Parce que Maven est un appareil pour réduire les hommes adultes à des masses sanglantes de terreur absolue.

Avantages:

• Gestion des dépendances. Depuis plusieurs années déjà, mes collègues et moi ne téléchargeons et ne gérons pas les dépendances manuellement. Cela permet un immense gain de temps.
• Indépendance IDE. Il s'avère que tous les principaux IDE, Eclipse, IDEA et NetBeans ont un support décent des projets Maven afin que nos développeurs ne soient pas enfermés dans un IDE particulier.
• Ligne de commande. Avec Maven, la prise en charge simultanée des configurations IDE et de ligne de commande est simple, ce qui est bon pour une intégration continue.

Les inconvénients:

• Vous devez investir dans l'apprentissage de Maven. Eh bien, dois le faire. Bonne nouvelle, tout le monde dans l'équipe n'a pas à apprendre.
• Documentation. Autrefois un problème, maintenant grâce à Sonatype et à leur livre ( http://www.sonatype.com/products/maven/documentation/book-defguide ), la situation est bien meilleure.
• Rigidité. Il est parfois difficile et frustrant de faire les choses comme vous le souhaitez. Mon conseil serait de ne pas se battre et de ne pas obliger Maven à faire les choses qu'il fait le mieux, des constructions simples ou quand un mojo stable est disponible. Dans d'autres cas, nous abandonnons et faisons des choses avec des tâches Ant ( http://maven.apache.org/plugins/maven-antrun-plugin/ ) ou des programmes externes. Mon préféré est Groovy plugun ( http://groovy.codehaus.org/GMaven ).

Compétition:

• Ant: n'a pas de gestion des dépendances. Période.
• Ivy: encore moins mature que Maven (non que ce dernier n'ait pas ses bizarreries aussi) Presque le même ensemble de fonctionnalités, donc aucune raison impérieuse de déménager. J'ai fait plusieurs tentatives pour l'essayer; tout échoue.

Conclusion: tous nos projets sont réalisés avec Maven depuis plusieurs années déjà.

Je pense qu'il a mauvaise réputation auprès des gens qui ont les projets les plus simples et les plus compliqués.

Si vous créez un seul WAR à partir d'une seule base de code, cela vous oblige à déplacer la structure de votre projet et à répertorier manuellement les deux des trois fichiers JAR dans le fichier POM.

Si vous construisez un EAR à partir d'un ensemble de neuf prototypes de fichiers EAR avec une combinaison de cinq fichiers WAR, trois EJB et 17 autres outils, des fichiers JAR de dépendances et des configurations qui nécessitent de peaufiner les fichiers MANIFEST.MF et XML dans les ressources existantes lors de la construction finale; alors Maven est probablement trop restrictif. Un tel projet devient un gâchis de profils imbriqués compliqués, de fichiers de propriétés et d'une mauvaise utilisation des objectifs de construction Maven et de la désignation du classificateur.

Donc, si vous êtes dans les 10% inférieurs de la courbe de complexité, c'est exagéré. Au sommet de 10% de cette courbe, vous êtes dans une camisole de force.

La croissance de Maven est due au fait qu'elle fonctionne bien pour les 80% du milieu

Mon expérience fait écho à la frustration de nombreux messages publiés ici. Le problème avec Maven est qu'il enveloppe et cache les détails de la gestion de build dans sa quête de la bonté automagique ultime. Cela vous rend presque impuissant s'il se brise.

Mon expérience est que tout problème avec maven a rapidement dégénéré en une chasse au snipe de plusieurs heures à travers des toiles de fichiers xml imbriqués, dans une expérience similaire à celle du canal radiculaire.

J'ai aussi travaillé dans des magasins qui comptaient beaucoup sur Maven, les gens qui l'ont aimé (qui l'aimaient pour l'aspect "appuyez sur un bouton, faites tout faire") ne l'ont pas compris. Les builds maven avaient un million de cibles automatiques, ce qui, j'en suis sûr, serait utile si j'avais envie de prendre des heures pour lire ce qu'ils ont fait. Mieux 2 cibles qui fonctionnent que vous comprenez parfaitement.

mise en garde: la dernière fois que j'ai travaillé avec Maven il y a 2 ans, ça va peut-être mieux maintenant.

Comme Glenn, je ne pense pas que Maven ait une mauvaise réputation, mais une représentation mitigée. Je travaille depuis 6 mois exclusivement en essayant de migrer un projet assez gros vers Maven et cela montre clairement les limites de l'outil.

D'après mon expérience, Maven est bon pour:

• gestion des dépendances externes
• gestion centralisée de la construction (héritage pom)
• beaucoup de plugins pour plein de choses
• très bonne intégration avec les outils d'intégration continue
• très bonnes capacités de reporting (FindBugs, PMD, Checkstyle, Javadoc, ...)

Et il a quelques problèmes avec:

• approche tout ou rien (difficile de migrer lentement vers Maven)
• dépendances complexes, dépendances intermodules
• dépendances cycliques (je sais, mauvaise conception, mais on ne peut pas réparer 5 ans de développement ...)
• cohérence (les gammes de versions ne fonctionnent pas de la même manière partout)
• bogues (encore une fois avec les gammes de versions)
• builds reproductibles (à moins que vous ne corrigiez le numéro de version de tous les plugins, vous ne pouvez pas être sûr que vous obtiendrez la même build dans 6 mois)
• manque de documentation (la documentation est assez bonne pour les bases, mais il n'y a pas beaucoup d'exemples sur la façon de gérer de grands projets)

Pour donner un peu de contexte, une trentaine de développeurs travaillent sur ce projet, et le projet existe depuis plus de 5 ans, donc: beaucoup d'héritage, beaucoup de processus déjà en place, beaucoup d'outils propriétaires personnalisés déjà en place. Nous avons décidé d'essayer de migrer vers Maven car le coût de maintenance de nos outils propriétaires devenait trop élevé.

Je voudrais contrer quelques-unes des plaintes formulées dans ce forum:

Maven est tout ou rien. Ou du moins pour autant que je puisse dire d'après la documentation. Vous ne pouvez pas facilement utiliser maven en remplacement de la fourmi et adopter progressivement des fonctionnalités plus avancées.

Ce n'est pas vrai. La grande victoire de Maven est de l'utiliser pour gérer vos dépendances de manière rationnelle et si vous voulez faire cela dans maven et faire tout le reste dans ant, vous pouvez. Voici comment:

<?xml version="1.0" encoding="UTF-8"?>
<project name="foo" basedir="." xmlns:maven="antlib:org.apache.maven.artifact.ant" >
  <maven:dependencies verbose="true" pathId="maven.classpath">
    <maven:pom id="maven.pom" file="pom.xml" />
  </maven:dependencies>
</project>

Vous avez maintenant un objet classpath nommé «maven.classpath» qui contient toutes les dépendances maven définies dans le fichier pom. Tout ce dont vous avez besoin est de mettre le fichier jar des tâches maven ant dans le répertoire lib de votre fourmi.

Maven rend votre processus de construction dépendant de votre connexion réseau.

Le processus de récupération des dépendances et des plugins par défaut dépend d'une connexion réseau, oui, mais uniquement pour la construction initiale (ou si vous modifiez les dépendances ou les plugins utilisés). Après cela, tous les fichiers JAR sont mis en cache localement. Et si vous voulez forcer la connexion sans réseau, vous pouvez dire à maven d'utiliser le mode hors ligne.

Il vous impose une structure rigide dès le départ.

Ce n'est pas clair si cela fait référence au format de fichier ou au problème de la «convention contre la configuration». Pour ce dernier, il y a beaucoup de valeurs par défaut invisibles comme l'emplacement attendu des fichiers source java et des ressources, ou la compatibilité de la source. Mais ce n'est pas de la rigidité, il s'agit de mettre des valeurs par défaut raisonnables pour vous afin que vous n'ayez pas à les définir explicitement. Tous les paramètres peuvent être remplacés assez facilement (bien que pour un débutant, il puisse être difficile de trouver dans la documentation comment changer certaines choses).

Si vous parlez du format de fichier, eh bien c'est couvert dans la réponse à la partie suivante ...

Il est basé sur XML, il est donc aussi difficile à lire que l'était ANT.

Tout d'abord, je ne vois pas comment vous pouvez vous plaindre du fait qu'un aspect de quelque chose «N'est pas meilleur que la fourmi» pour justifier une mauvaise réputation. Deuxièmement, bien qu'il soit toujours XML, le format du XML est beaucoup plus défini. De plus, comme il est ainsi défini, il est beaucoup plus facile de créer un éditeur de client lourd sensible pour un POM. J'ai vu des pages longues et créer des scripts qui sautent partout. Aucun éditeur de script de construction de fourmis ne rendra cela plus acceptable, juste une autre longue liste de tâches interconnectées présentées d'une manière légèrement différente.

Cela dit, il y a quelques plaintes que j'ai vues ici qui ont ou avaient une certaine validité, la plus grande étant

• La documentation est pauvre / manquante
• Constructions reproductibles
• L'intégration d'Eclipse est mauvaise
• Bugs

A quoi ma réponse est double. Premièrement, Maven est un outil beaucoup plus récent que Ant ou Make, vous devez donc vous attendre à ce que cela prenne du temps pour atteindre le niveau de maturité de ces applications. Deuxièmement, si vous ne l'aimez pas, corrigez-le . C'est un projet open source et l'utiliser, puis se plaindre de quelque chose que tout le monde peut aider à résoudre me semble assez absurde. Vous n'aimez pas la documentation? Contribuez-y pour le rendre plus clair, plus complet ou plus accessible à un débutant.

Le problème des builds reproductibles se décompose en deux problèmes, les gammes de versions et les mises à jour automatiques du plugin maven. Pour les mises à jour du plugin, à moins que vous ne vous assuriez, lorsque vous reconstruisez un projet un an plus tard, que vous utilisez exactement le même JDK et exactement la même version d'Ant, bien c'est juste le même problème avec un nom différent. Pour les gammes de versions, je recommande de travailler sur un plugin qui produira un pom temporaire avec des versions verrouillées pour toutes les dépendances directes et transitives et l'intègrera au cycle de vie de la version maven. De cette façon, vos poms de build de version sont toujours des descriptions exactes de toutes les dépendances.

Il mérite la réputation qu'il a. Tout le monde n'a pas besoin de la structure rigide que les développeurs de Maven pensaient appropriée pour chaque projet. C'est tellement inflexible. Et ce qui est «Pro» pour beaucoup de gens, la gestion des dépendances, est à mon humble avis son plus gros «con». Je ne suis absolument pas à l'aise avec le fait que maven télécharge les fichiers jar depuis le réseau et je perds mon sommeil à cause d'incompatibilités (oui, le mode hors ligne existe, mais alors pourquoi devrais-je avoir toutes ces centaines de fichiers xml et de sommes de contrôle). Je décide quelles bibliothèques j'utilise et de nombreux projets sont sérieusement préoccupés par les versions dépendant de la connexion réseau.

Pire encore, lorsque les choses ne fonctionnent pas, vous êtes absolument perdu. La documentation est nulle, la communauté n'a aucune idée.

Un an plus tard, je voulais mettre à jour ceci: je n'ai plus cet avis sur la communauté Maven. Je n'écrirais pas cette réponse si la question était posée aujourd'hui. Je vais ajouter mon opinion actuelle en tant que réponse distincte.

C'est une réponse très subjective, mais la question porte sur les opinions, donc ...

J'aime Maven et je l'aime mieux à mesure que je le connais. Une chose qui affecte mes sentiments à ce sujet, cependant: la communauté maven est largement centrée autour de Sonatype ("la société maven", c'est là que beaucoup de honchos Maven travaillent), et Sonatype pousse ses produits d'entreprise de manière assez agressive sur la communauté.

Un exemple: le flux Twitter «Maven Book» renvoie à une prétendue introduction à la gestion des référentiels .

Désolé, mais cette "intro" est mi-information, mi-argument de vente pour Nexus. Quiz Pop: y a-t-il d' autres gestionnaires de repo en plus de Nexus et Nexus Pro? De plus, qu'est-ce que cela a à voir avec le soi-disant livre Maven open-source? Oh, c'est vrai, le chapitre sur la gestion des référentiels a été transformé en un livre séparé ... sur Nexus. Huh. Si je contribue au livre Maven, est-ce que je reçois des frais de parrainage si je provoque une augmentation des ventes Nexus?

Imaginez si vous participiez à un forum de développement Java et qu'il était clair que les employés de Sun discutant de Java allaient saisir toutes les occasions possibles pour parler de NetBeans et de "NetBeans Pro". Après un certain temps, il perd un peu de son sentiment communautaire. Je n'ai jamais eu une expérience pareille avec Ant.

Cela dit, je pense que Maven est un système très intéressant et utile (je ne l'appelle pas un outil, comme Ant est, Maven est plus large que cela) pour la configuration du développement logiciel et la gestion des builds. La gestion des dépendances est parfois une bénédiction et une malédiction, mais elle est rafraîchissante - et certainement pas le seul avantage offert par Maven. Je réagis probablement un peu trop fortement au shilling Sonatype, mais ça fait mal à Maven par association, à mon avis. Je ne sais pas si cette opinion est partagée par quelqu'un d'autre.

Je pense que Maven a mauvaise réputation car il impose une structure à votre projet, alors que d'autres outils comme Ant vous permettent de définir complètement la structure comme vous le souhaitez. Je suis également d'accord pour dire que la documentation est mauvaise, mais je pense que la mauvaise réputation de Maven est principalement due au fait que les gens sont tellement habitués à Ant.

Trop de magie.

Parce que les gens insatisfaits se plaignent tandis que les gens satisfaits ne se disent pas satisfaits. Mon point est qu'il y a beaucoup plus d'utilisateurs de maven satisfaits que d'insatisfaits, mais ces derniers font plus de bruit. C'est un modèle courant de la vie réelle (FAI, opérateur de téléphonie, transports, etc.).

Le problème le plus important pour moi est que Maven, lorsqu'il n'est pas configuré correctement, peut ne pas produire de builds répétables, en raison de:

• référentiels distants peu fiables;
• dépendances sur les plugins et les bibliothèques avec soit des versions SNAPSHOT, soit aucune version.

Comparez cela avec une construction de fourmi qui - bien que verbeuse et ennuyeuse IMO - fonctionne puisque tous les pots sont enregistrés localement.

L'avantage est que les problèmes sont résolus:

• utilisez votre propre référentiel maven, qui est devenu très simple, j'utilise Archiva avec de bons résultats;
• version toujours correctement vos dépendances. Maven a commencé à verrouiller les versions de plug-in dans le super-POM à partir de 2.0.8 ou 2.0.9 et toutes vos dépendances devraient être sur les versions publiées.

excellente idée - mauvaise mise en œuvre.

J'ai récemment déménagé un projet de Ant à Maven. Cela a bien fonctionné à la fin, mais j'ai dû utiliser deux versions différentes de maven-assembly-plugin et maven-jar-plugin dans le même pom (obtenu deux profils) car ce qui fonctionnait dans une version était cassé dans une autre.

C'était donc un véritable casse-tête. La documentation n'est pas toujours excellente, mais je dois admettre qu'il était relativement facile de trouver des réponses sur Google.

assurez-vous de toujours spécifier les versions des plugins que vous utilisez. Ne vous attendez pas à ce que la nouvelle version soit rétrocompatible.

Je pense que la controverse vient du fait que maven évolue encore et que le processus est parfois douloureux.

Cordialement

v.

J'aime maven. Je l'ai utilisé depuis la version antérieure à 1.0. C'est un outil puissant qui, dans l'ensemble, m'a fait gagner un temps considérable et amélioré mon infrastructure de développement. Mais je peux comprendre la frustration de certaines personnes. Je vois 3 types de frustration:

1. où les causes sont de réelles préoccupations (par exemple POM verbeux, manque de documentation),
2. une partie est de la désinformation (par exemple "vous devez avoir une connexion Internet pour construire" - pas vrai - non, cela peut être évité),
3. une partie est évacuée sur maven mais en réalité quelqu'un d'autre est coupable ("ne tirez pas sur le messager").

Pour le premier cas, de vrais problèmes - eh bien, bien sûr, il y a des problèmes, les POM sont verbeux, la documentation pourrait être meilleure. Pourtant, malgré cela, il est possible d'obtenir de bons résultats avec maven en un rien de temps. Je grince des dents chaque fois que je reçois un projet construit avec fourmi, et j'essaye de l'importer dans mon IDE. La configuration de la structure des répertoires peut prendre un certain temps. avec maven, il s'agit simplement d'ouvrir le fichier POM dans l'IDE.

Pour le second cas, Maven est complexe et les malentendus sont monnaie courante. Si maven 3 peut trouver un moyen de traiter cette complexité (ou même la complexité perçue), ce serait bien. maven demande un investissement considérable, mais, d'après mon expérience, l'investissement se rentabilise rapidement.

Pour le dernier point, je pense que le reproche concernant les dépendances transitives de maven est probablement l'exemple le plus connu.

Les dépendances transitives sont la nature des logiciels réels utilisant la réutilisation. Les DLL Windows, les packages Debian, les packages java, les bundles OSGi, même les fichiers d'en-tête C ++ incluent tous des dépendances et souffrent du problème de dépendance. Si vous avez deux dépendances et que chacune utilise une version différente de la même chose, vous devez essayer de résoudre cela d'une manière ou d'une autre. Maven n'essaie pas de résoudre le problème de dépendance, mais le met plutôt au premier plan et fournit des outils pour aider à gérer le problème, par exemple en signalant les conflits et en fournissant des dépendances cohérentes pour une hiérarchie de projets, et en fait, fournit un contrôle absolu sur les dépendances d'un projet.

L'approche consistant à inclure manuellement les dépendances avec chaque projet (un poster dit qu'il vérifie toutes les dépendances dans le contrôle de code source) court le risque d'utiliser la mauvaise dépendance, comme des mises à jour négligées lorsqu'une bibliothèque est mise à jour sans vérifier les mises à jour pour ses dépendances. Pour un projet de toute taille, la gestion manuelle des dépendances va sûrement entraîner des erreurs. Avec maven, vous pouvez mettre à jour la version de la bibliothèque que vous utilisez et les dépendances correctes sont incluses. Pour la gestion des changements, vous pouvez comparer l'ancien ensemble de dépendances (pour votre projet dans son ensemble) avec le nouvel ensemble, et tout changement peut être soigneusement examiné, testé, etc.

Maven n'est pas la cause du problème de dépendance, mais le rend plus visible. En abordant les problèmes de dépendance, maven rend toute dépendance explicite (une modification de votre POM remplaçant la dépendance), plutôt qu'implicite, comme c'est le cas avec les fichiers JAR gérés manuellement dans le contrôle de version, où les fichiers JAR sont simplement présents, sans rien à support météo ils sont la dépendance correcte ou non.

Je pense que Maven a une mauvaise réputation car la plupart des détracteurs n'ont pas observé la combinaison Maven + Hudson + Sonar . S'ils l'avaient fait, ils demanderaient «comment puis-je commencer»?

Certains de mes bêtes noires avec Maven:

• La définition XML est super maladroite et verbeuse. N'ont-ils jamais entendu parler des attributs?

• Dans sa configuration par défaut, il parcourt toujours le filet à chaque opération. Indépendamment du fait que cela soit utile pour quoi que ce soit, il semble extrêmement ridicule d'avoir besoin d'un accès Internet pour «nettoyer».

• Encore une fois par défaut, si je ne fais pas attention à spécifier les numéros de version exacts, il retirera les toutes dernières mises à jour du net, que ces dernières versions introduisent ou non des erreurs de dépendance. En d'autres termes, vous êtes mis à la merci de la gestion de la dépendance des autres.

• La solution à tout cet accès réseau est de le désactiver en ajoutant l' -ooption. Mais vous devez vous rappeler de le désactiver si vous voulez vraiment mettre à jour les dépendances!

• Une autre solution consiste à installer votre propre serveur de «contrôle de source» pour les dépendances. Surprise: la plupart des projets ont déjà un contrôle de source, mais cela fonctionne sans configuration supplémentaire!

• Les builds Maven sont incroyablement lents. Le fait de jouer avec les mises à jour réseau atténue cela, mais les versions de Maven sont encore lentes. Et horriblement bavard.

• Le plugin Maven (M2Eclipse) s'intègre le plus mal avec Eclipse. Eclipse s'intègre raisonnablement facilement avec le logiciel de contrôle de version et avec Ant. L'intégration Maven est très maladroite et laide en comparaison. Ai-je mentionné lent?

• Maven continue de boguer. Les messages d'erreur sont inutiles. Trop de développeurs en souffrent.

Bonne question. Je viens de démarrer un grand projet au travail et une partie des projets précédents consistait à introduire la modularité dans notre base de code.

J'ai entendu de mauvaises choses sur maven. En fait, c'est tout ce que j'en ai jamais entendu. J'ai cherché à l'introduire pour résoudre le cauchemar de dépendance que nous vivons actuellement. Le problème que j'ai vu avec Maven est qu'il est assez rigide dans sa structure, c'est-à-dire que vous devez vous conformer à la disposition de son projet pour qu'il fonctionne pour vous.

Je sais ce que la plupart des gens diront - vous n'avez pas à vous conformer à la structure. En effet, c'est vrai, mais vous ne le saurez pas tant que vous n'aurez pas dépassé la courbe d'apprentissage initiale, à partir de laquelle vous avez investi trop de temps pour tout jeter.

La fourmi est beaucoup utilisée ces jours-ci, et j'adore ça. En tenant compte de cela, je suis tombé sur un gestionnaire de dépendances peu connu appelé Apache Ivy . Ivy s'intègre très bien dans Ant et il est rapide et facile d'obtenir la configuration et le fonctionnement de base de la récupération JAR. Un autre avantage d'Ivy est qu'il est très puissant mais tout à fait transparent; vous pouvez transférer des builds en utilisant des mécanismes tels que scp ou ssh assez facilement; Récupération de dépendances en chaîne sur des systèmes de fichiers ou des référentiels distants (la compatibilité des dépôts Maven est l'une de ses fonctionnalités populaires).

Cela dit, j'ai trouvé cela très frustrant à utiliser à la fin - la documentation est abondante, mais elle est écrite en mauvais anglais, ce qui peut ajouter à la frustration lors du débogage ou de la tentative de résolution de ce qui ne va pas.

Je vais revoir Apache Ivy à un moment donné au cours de ce projet et j'espère le faire fonctionner correctement. Il nous a permis en tant qu'équipe de déterminer de quelles bibliothèques nous dépendons et d'obtenir une liste documentée.

En fin de compte, je pense que tout dépend de la façon dont vous travaillez en tant qu'individu / équipe et de ce dont vous avez besoin pour résoudre vos problèmes de dépendance.

Les ressources suivantes relatives à Ivy peuvent vous être utiles:

• Comparaison entre Apache Ivy et Maven 2
• FAQ sur Apache Ivy
• Liste des fonctionnalités d'Apache Ivy

J'adore Maven - cela augmente la productivité, et je suis très heureux de ne plus utiliser Ant (ouf!)

Mais si je pouvais changer les choses, ce serait:

1. Rendre le pom.xmlfichier moins détaillé
2. Facilitez l'inclusion de fichiers .jars non issus du référentiel.

Il y a beaucoup de raisons pour lesquelles les gens n'aiment pas Maven, mais admettons-le, ils sont très subjectifs . Maven aujourd'hui avec de bons livres (et gratuits), une meilleure documentation, un ensemble plus complet de plugins et beaucoup de constructions de projets référentiels réussis n'est pas le même Maven qu'il y a un ou deux ans.

Utiliser Maven dans des projets simples est très facile, avec des projets plus grands / compliqués, il faut plus de connaissances et une compréhension plus profonde de la philosophie Maven - peut-être au niveau de l'entreprise un poste pour le gourou Maven comme administrateur de réseau. La principale source des déclarations de haine de Maven est souvent l' ignorance .

Un autre inconvénient pour Maven est le manque de flexibilité comme par exemple dans Ant. Mais rappelez-vous que Maven a un ensemble de conventions - s'y tenir semble être difficile au début, mais en fin de compte souvent épargner des problèmes.

Le succès actuel de Maven prouve sa valeur. Bien sûr, personne n'est parfait et Maven a quelques inconvénients et ses bizarreries, mais à mon avis, Maven balance lentement ses adversaires.

Je ne dirais pas qu'il a une mauvaise réputation tant qu'il a un représentant mixte. Si votre projet suit le paradigme de la «convention sur la configuration» préconisé par Maven, vous pouvez en tirer beaucoup de profit. Si votre projet ne correspond pas bien à la vision du monde de Maven, il peut devenir un fardeau.

À cette fin, si vous avez le contrôle sur le projet, Maven peut être la voie à suivre. Mais si vous ne le faites pas et que la mise en page est déterminée par quelqu'un qui n'est pas fan de Maven, cela peut poser plus de problèmes que cela ne vaut la peine. Les projets Maven les plus heureux sont probablement ceux qui ont commencé comme des projets Maven.

Pour moi, il y a autant d'avantages que d'inconvénients à utiliser maven vs ant pour des projets internes. Pour les projets open source cependant, je pense que Maven a eu un grand impact en rendant de nombreux projets beaucoup plus faciles à construire. Il n'y a pas si longtemps, il fallait des heures pour compiler le projet OSS Java (basé sur une fourmi) moyen, devoir définir une tonne de variables, télécharger des projets dépendants, etc.

Vous pouvez faire tout ce que vous pouvez faire avec Maven avec Ant, mais là où Ant n'encourage aucune norme, Maven vous suggère fortement de suivre sa structure, sinon ce sera plus de travail. Certes, certaines choses sont difficiles à mettre en place avec Maven, ce qui serait facile à faire avec Ant, mais le résultat final est presque toujours quelque chose de plus facile à construire du point de vue des personnes qui veulent simplement vérifier un projet et partir.

Si vous comptez parier votre entreprise ou votre travail sur un projet de développement, vous voulez être en contrôle des fondations - c'est-à-dire du système de construction. Avec Maven, vous n'avez pas le contrôle. Il est déclaratif et opaque. Les développeurs de maven-framework n'ont aucune idée de la façon de créer un système transparent ou intuitif et cela ressort clairement de la sortie du journal et de la documentation.

La gestion des dépendances est très tentante car elle pourrait vous même un certain temps au démarrage du projet mais attention, elle est fondamentalement cassée et vous causera éventuellement beaucoup de maux de tête. Lorsque deux dépendances ont des dépendances transitoires incompatibles, vous serez bloqué par un nid de complexité qui interrompra la construction de toute votre équipe et bloquera le développement pendant des jours. Le processus de construction avec Maven est également notoirement incohérent pour les différents développeurs de votre équipe en raison des états incohérents de leurs référentiels locaux. Selon le moment où un développeur a créé son environnement ou les autres projets sur lesquels il travaille, les résultats seront différents. Vous constaterez que vous supprimez l'intégralité de votre référentiel local et que Maven télécharge à nouveau les fichiers JAR beaucoup plus souvent que lors de la première configuration pour une branche de développement. Je pense que l'OSGI est une initiative qui tente de résoudre ce problème fondamental. Je dirais que si quelque chose doit être si complexe, la prémisse fondamentale est erronée.

Je suis un utilisateur / victime maven depuis plus de 5 ans maintenant et je dois dire que cela vous fera gagner beaucoup plus de temps pour simplement vérifier vos dépendances dans votre référentiel source et écrire des tâches de fourmis simples et agréables. Avec fourmi, vous savez exactement ce que fait votre système de construction.

J'ai vécu de nombreuses semaines d'homme perdues dans plusieurs entreprises différentes en raison de problèmes de Maven.

J'ai récemment essayé de redonner vie à un ancien projet GWT / Maven / Eclipse et 2 semaines de tout mon temps libre plus tard, je n'arrive toujours pas à le construire de manière cohérente. Il est temps de réduire mes pertes et de me développer en utilisant fourmi / éclipse me pense ...

La réponse courte: j'ai trouvé très difficile de maintenir un système de construction Maven, et j'aimerais passer à Gradle dès que possible.

Je travaille avec Maven depuis plus de quatre ans. Je me qualifierais d'expert en systèmes de construction parce que dans les cinq dernières (au moins) dernières entreprises dans lesquelles j'ai été, j'ai effectué des rénovations majeures sur l'infrastructure de construction / déploiement.

Certaines des leçons que j'ai apprises:

• La plupart des développeurs ont tendance à ne pas passer beaucoup de temps à réfléchir aux systèmes de construction; en conséquence, la construction se transforme en un gâchis spaghetti de hacks, mais ils apprécient quand ce gâchis est nettoyé et rationalisé.
• Pour gérer la complexité, je préférerais avoir un système transparent qui expose la complexité (comme Ant) plutôt qu'un système qui essaie de simplifier les choses complexes en imposant des restrictions rigides, comme Maven. Pensez à Linux par rapport à Windows.
• Maven a beaucoup de lacunes dans les fonctionnalités qui nécessitent des solutions de contournement byzantines. Cela conduit à des fichiers POM qui sont incompréhensibles et non maintenables.
• Ant est super flexible et compréhensible, mais les fichiers Ant peuvent aussi devenir assez gros, car ils sont de si bas niveau.
• Pour tout projet important, les développeurs doivent créer leur propre structure de construction / déploiement au-delà de ce que l'outil fournit; l'adéquation de la structure au projet a beaucoup à voir avec sa facilité d'entretien. Les meilleurs outils vous aideront à créer une structure et non à vous combattre.

J'ai regardé un peu Gradle et il semble qu'il a le potentiel d'être le meilleur des deux mondes, permettant un mélange de description de construction déclarative et procédurale.

C'est plus compliqué que la langue que vous avez utilisée pour écrire votre projet. Le configurer correctement est plus difficile que la programmation réelle.

J'ai eu du mal à traverser la plupart / tous les négatifs mentionnés ici, et les objections similaires des coéquipiers, et je suis d'accord avec eux tous. Mais j'ai tenu bon et je continuerai de le faire en me tenant fermement au seul objectif que seul maven (ou gradle peut-être) réalise vraiment.

Si vous optimisez pour des pairs ( développeurs open source ), ant / make / what will do. Si vous fournissez des fonctionnalités à des non-pairs ( utilisateurs ), seul maven / gradle / etc fera l'affaire.

Seul maven vous permet de publier un petit paquet de code source + poms (pas de fichiers de dépendances lib / binaires intégrés avec des noms cryptiques et aucune information de dépendance) avec une mise en page de projet standard bien documentée qui peut être chargée par n'importe quel IDE par quelqu'un qui n'a pas absorbé les conventions de mise en page idiosyncratiques des développeurs. Et il existe une procédure d'installation à un bouton (mvn install) qui construit tout tout en acquérant les dépendances manquantes.

Le résultat est une rampe d'accès facile que les utilisateurs peuvent suivre pour trouver leur chemin dans le code, où les poms peuvent les diriger vers la documentation pertinente.

En dehors de cette exigence (indispensable), je n'aime pas maven autant que quiconque.