comparaison de sbt et Gradle [fermé]

Je plonge dans Scala et remarque sbt. J'ai été assez satisfait de Gradle dans les projets java / groovy, et je sais qu'il existe un plugin scala pour Gradle.

Quelles pourraient être de bonnes raisons de privilégier sbt à Gradle dans un projet Scala?

Notez qu'une différence clé entre SBT et Gradle est sa gestion des dépendances :

• SBT : Ivy , avec une révision qui peut être donnée comme une version fixe (1.5.2, par exemple) ou comme la dernière (ou dynamique).
  Voir « Dépendance Ivy »
  Cela signifie que le support du mécanisme «-SNAPSHOT» peut être problématique, même si Mark Harrah détaille dans ce fil :

Il est vrai que le cache peut devenir confus, mais ce n'est pas vrai qu'Ivy ne comprend pas la résolution des instantanés. Eugene a expliqué ce point dans un autre fil, peut-être sur la liste des administrateurs. Il y a un problème avec la mise à jour automatique de sbt qui a été résolu dans la version 0.12.

Ce que Ivy ne prend pas en charge, pour autant que je sache, c'est la publication d'instantanés à la manière de Maven. Je crois que j'ai dit cela ailleurs, mais si quelqu'un veut améliorer la situation, mon opinion est qu'il vaut mieux faire l'effort de travailler avec l'équipe Gradle pour réutiliser son code de gestion des dépendances.

• Gradle : Ce fil mentionne ( Peter Niederwieser ):

Juste pour vous le faire savoir, les problèmes avec les dépendances de snapshot Ivy et Maven étaient l'une des raisons pour lesquelles Gradle a finalement remplacé Ivy par son propre code de gestion des dépendances. C'était une tâche énorme, mais nous a apporté beaucoup de bonté.

Ce tweet mentionne que toute la situation pourrait évoluer à l'avenir:

Mark a dit dans le passé qu'il était intéressé à utiliser Gradle au lieu d'Ivy pour SBT.

(les deux outils peuvent apprendre l'un de l'autre )

Pour moi, les principales caractéristiques de SBT sont:

• Compilation rapide (plus rapide que fsc).
• Compilation / tests continus: la commande ~testrecompilera et testera votre projet à chaque fois que vous enregistrez une modification.
• Compilation croisée et publication croisée, sur plusieurs versions de scala.
• Récupération automatique des dépendances avec la compatibilité de version scala correcte.

Les inconvénients sont:

• Une syntaxe hiéroglyphique qui a tendance à décourager les nouveaux utilisateurs (surtout s'ils viennent de Java)
• Pas de moyen simple de définir une "tâche": si vous avez besoin d'une procédure de construction spéciale, vous devrez soit trouver un plugin, soit écrire un plugin vous-même.

sbt est un DSL Scala et pour cela Scala est un citoyen de première classe, donc en principe, il semble être un bon choix.

Mais sbt souffre de changements incompatibles majeurs entre les versions, ce qui rend difficile de trouver le bon plugin fonctionnel pour une tâche et de le faire fonctionner.

J'ai personnellement abandonné sbt, car cela posait plus de problèmes qu'il n'en résolvait. Je suis en fait passé à gradle.

Allez comprendre.

Je suis assez nouveau dans gradle, et très nouveau dans sbt - ce que j'aime vraiment dans sbt jusqu'à présent, c'est la console interactive. Cela me permet d'utiliser des commandes comme «inspecter» pour avoir une meilleure idée de ce qui se passe. AFAIK gradle ne fournit pas quelque chose comme ce atm.

Sbt et gradle, tous deux sont basés sur des langages typés statiquement ... mais sbt a peu d'avantages:

• meilleur support des plugins, spécialement les autoplugins
• création de tâches et gestion des dépendances entre les tâches
• sbt convient particulièrement aux projets scala dans le sens où il prend en charge les builds incrémentiels et la plupart des sbt lui-même sont écrits en scala et les définitions de build sbt sont écrites en scala
• sbt prend en charge le shell interactif avec de nombreuses tâches intégrées utiles
• Le cycle de vie par défaut de sbt est assez utile et permet aux novices de démarrer avec moins d'effort