Quelles sont les principales différences entre Scala et Groovy? [fermé]

En surface, Groovy et Scala se ressemblent assez, mis à part le fait que Scala est typé statiquement et Groovy dynamique.

• Quelles sont les autres différences clés et les avantages de chacun par rapport à l'autre?
• Dans quelle mesure sont-ils vraiment similaires?
• Y a-t-il concurrence entre les deux?
  • Si tel est le cas, selon vous, qui gagnera à long terme?

Ce sont tous deux des langages orientés objet pour la JVM qui ont des lambdas et des fermetures et qui interagissent avec Java. À part cela, ils sont extrêmement différents.

Groovy est un langage «dynamique» non seulement dans le sens où il est typé dynamiquement, mais qu'il prend en charge la méta-programmation dynamique.

Scala est un langage "statique" en ce sens qu'il est typé statiquement et n'a pratiquement pas de méta-programmation dynamique au-delà des choses gênantes que vous pouvez faire en Java. Notez que le système de type statique de Scala est nettement plus uniforme et sophistiqué que celui de Java.

Groovy est syntaxiquement influencé par Java mais sémantiquement davantage influencé par des langages comme Ruby.

Scala est syntaxiquement influencé par Ruby et Java. Il est davantage influencé sémantiquement par Java, SML, Haskell et un langage OO très obscur appelé gBeta.

Groovy a une distribution multiple "accidentelle" en raison de la façon dont il gère la surcharge Java.

Scala est une distribution unique uniquement, mais a une correspondance de modèle inspirée de SML pour traiter certains des mêmes types de problèmes que l'envoi multiple est censé gérer. Cependant, lorsque la distribution multiple ne peut être distribuée que sur le type d'exécution, la correspondance de modèle de Scala peut distribuer les types d'exécution, les valeurs ou les deux. La correspondance de modèles comprend également une liaison de variables syntaxiquement agréable. Il est difficile d'exagérer à quel point cette fonctionnalité unique rend la programmation dans Scala.

Scala et Groovy prennent en charge une forme d'héritage multiple avec des mixins (bien que Scala les appelle des traits).

Scala prend en charge à la fois l'application de fonction partielle et le curry au niveau du langage, Groovy a une méthode "curry" maladroite pour faire une application de fonction partielle.

Scala effectue une optimisation directe de la récursivité de la queue. Je ne crois pas que Groovy le fasse. C'est important dans la programmation fonctionnelle mais moins important dans la programmation impérative.

Scala et Groovy sont évalués avec impatience par défaut. Cependant, Scala prend en charge les paramètres d'appel par nom. Groovy ne le fait pas - l'appel par nom doit être émulé avec des fermetures.

Scala a "pour les compréhensions", une généralisation des compréhensions de listes trouvées dans d'autres langages (techniquement, ce sont des compréhensions monades plus un peu - quelque part entre le do de Haskell et le LINQ de C #).

Scala n'a aucun concept de champs "statiques", de classes internes, de méthodes, etc. - il utilise à la place des objets singleton. Groovy utilise le concept statique.

Scala n'a pas intégré la sélection d'opérateurs arithmétiques de la même manière que Groovy. Dans Scala, vous pouvez nommer les méthodes de manière très flexible.

Groovy a l'opérateur elvis pour traiter null. Les programmeurs Scala préfèrent utiliser les types Option à l'utilisation de null, mais il est facile d'écrire un opérateur elvis dans Scala si vous le souhaitez.

Enfin, il y a des mensonges, il y a des mensonges fous, et puis il y a des repères. Le jeu de référence en langage informatique classe Scala comme étant sensiblement plus rapide que Groovy (allant de deux à 93 fois plus rapide) tout en conservant à peu près la même taille de source. repères .

Je suis sûr qu'il existe de très nombreuses différences que je n'ai pas couvertes. Mais j'espère que cela vous donne une idée essentielle.

Y a-t-il une concurrence entre eux? Oui, bien sûr, mais pas autant que vous ne le pensez. La vraie concurrence de Groovy est JRuby et Jython.

Qui va gagner? Ma boule de cristal est aussi fissurée que celle des autres.

scala est censé être un langage hybride oo / fonctionnel et est très bien planifié et conçu. groovy ressemble plus à un ensemble d'améliorations que beaucoup de gens aimeraient utiliser en java. J'ai regardé de plus près les deux, donc je peux le dire :)

aucun d'eux n'est meilleur ou pire que l'autre. groovy est très bon en méta-programmation, scala est très bon dans tout ce qui n'a pas besoin de méta-programmation, donc ... j'ai tendance à utiliser les deux.

Scala dispose d'acteurs, ce qui facilite la mise en œuvre de la concurrence. Et les traits qui donnent un héritage multiple vrai et sécurisé.

Vous avez frappé dans le mille avec la frappe statique et dynamique. Les deux font partie de la nouvelle génération de langages dynamiques, avec des fermetures, des expressions lambda, etc. Il existe également une poignée de différences syntaxiques entre les deux, mais fonctionnellement, je ne vois pas de différence énorme entre Groovy et Scala.

Scala implémente les listes un peu différemment; dans Groovy, à peu près tout est une instance de java.util.List, alors que Scala utilise à la fois des listes et des tableaux primitifs. Groovy a (je pense) une meilleure interpolation des cordes.

Scala est plus rapide, semble-t-il, mais les gens de Groovy poussent vraiment les performances pour la version 2.0. 1.6 a donné un énorme bond de vitesse par rapport à la série 1.5.

Je ne pense pas que l'une ou l'autre des langues «gagnera» vraiment, car elles ciblent deux classes différentes de problèmes. Scala est un langage très performant qui ressemble beaucoup à Java sans avoir tout à fait le même niveau de passe-partout que Java. Groovy est destiné au prototypage et au développement rapides, où la vitesse est moins importante que le temps nécessaire aux programmeurs pour implémenter le code.

Scala a une courbe d'apprentissage beaucoup plus raide que Groovy. Scala a beaucoup plus de support pour la programmation fonctionnelle avec sa correspondance de modèles et sa récursivité basée sur la queue, ce qui signifie plus d'outils pour la FP pure.

Scala a également une compilation dynamica et je l'ai fait en utilisant twitter eval lib ( https://github.com/twitter/util ). J'ai conservé le code scala dans un fichier plat (sans aucune extension) et en utilisant eval créé la classe scala au moment de l'exécution. Je dirais que scala est une métaprogrammation et a une fonction de complication dynamique