Que pensent les développeurs Java de Scala? [fermé]

J'ai remarqué que le support IDE est loin d'être aussi bon, mais le langage lui-même prend en charge les idiomes de programmation fonctionnelle beaucoup plus proprement.

Je programme Scala depuis plus d'un an maintenant, je vais donc essayer de me reculer d'un an pour répondre à cette question.

• Le code Scala est plus concis que le code Java (pas de setter ou getter, beaucoup d'informations de type peuvent être déduites)
• La prise en charge intégrée du littéral XML est très attrayante.
• La compatibilité et l'interopérabilité des bibliothèques Java sont excellentes
• Le support de certains idiomes fonctionnels est rafraîchissant (pour la compréhension, la fermeture, les fonctions lambda, cartographier, plier, réduire)
• Il ne semble pas y avoir de fonctionnalité intéressante que le créateur du langage ne voulait pas inclure

Les points ci-dessus étaient plus ou moins ce que je pensais de Scala avant de commencer à l'apprendre.

En un an, voici ce que j'ai découvert:

• L'achat du livre d'escalier a été un excellent investissement et m'a sauvé des heures d'apprentissage par moi-même
• La syntaxe a quelques bizarreries et il y avait parfois où j'étais vraiment perplexe pourquoi quelque chose n'était pas valide. Le compromis est une fois que vous êtes familier, le code a moins d'encombrement et est plus facile à lire. Notez que ce n'est pas vraiment un problème si vous lisez plutôt que d'écrire du code.
• La bibliothèque de collection en 2.8 est un plaisir à utiliser. Il est difficile de revenir à Java.
• Le littéral XML est bien, mais au-delà de certaines choses de base, j'ai dû aller à l'écosystème de la bibliothèque Java. C'est pratique cependant.
• L'utilisation des bibliothèques Java de Scala est super facile et pratique. L'utilisation des classes Scala de Java est un peu plus délicate, mais cela fonctionne.
• Je suis passé à l'édition communautaire IntelliJ IDEA et bien qu'il ne soit pas parfait, il est plus que suffisant.
• Le créateur du langage a vraiment pensé à l'ensemble des fonctionnalités et tout fonctionne très bien ensemble. Le support orienté objet est meilleur qu'en Java (avec les traits) et vous pouvez faire de la programmation fonctionnelle.
• C'est un langage que certains développeurs Java détestent apparemment avec passion. Pour moi, cela a ramené le plaisir de la programmation.

Eh bien, je pense que Scala est trop complexe. Cela ressemble au C ++ en ce qu'il a une myriade de façons différentes de faire les choses. Certains appellent cela «richesse», «expressivité» ou «puissance», mais votre kilométrage peut varier. Dans de nombreux projets du monde réel, vous devrez limiter artificiellement les fonctionnalités du langage que vous allez utiliser et ce qui ne l'est pas, afin que tous les développeurs impliqués puissent parler le même sous-ensemble du langage.

Pour la programmation fonctionnelle, je préfère Clojure , qui est beaucoup plus simple que Scala.

Que la guerre sainte commence ;-)

Il y a environ un an, comme je devenais de plus en plus frustré par l'avenir des produits de ma startup si je continuais à utiliser Java, j'ai décidé d'essayer Scala. Je programmais déjà en JavaScript et Python à l'époque, Ruby était aussi une bonne alternative, mais je cherchais un langage typé statiquement, de préférence un qui pourrait s'exécuter sur la JVM.

J'ai vraiment essayé d'aimer Scala, je l'ai vraiment fait, mais j'ai trouvé que le code était vraiment moche et difficile à comprendre. Je me demandais dramatiquement que si Scala était notre meilleure réponse à Java, alors j'étais sûrement foutu et condamné à continuer à travailler avec un langage que je n'aimais pas après tout ...

Heureusement, peu de temps après, j'ai découvert Fantom . Oh mec, je l'ai adoré! Pour moi, c'était comme la splendeur de l'américain face à la bureaucratie allemande! Cela correspondait aux exigences que je recherchais à Scala, mais de manière beaucoup plus élégante . Il avait l' intégration de Vim , Eclipse et Netbeans , un cadre Web agréable , des produits matures fonctionnant avec lui, une petite mais incroyablement utile communauté ... Typage dynamique et statique! Je me suis réjoui!

(Je pourrais continuer mais ce post est censé être sur Scala, pas sur Fantom, donc je m'arrête ici. Ma préférence est claire , néanmoins il y a ce post comparant les deux. Je n'ai jamais pu comprendre pourquoi Fantom reçoit si peu d'attention par rapport à Scala. Mais apparemment, je ne suis pas le seul, si vous écoutez ce podcast [ mp3 ] jusqu'à la fin.)

Lorsque j'ai commencé à essayer Scala il y a 2 ans, cela me semblait étrange et intimidant. À un moment donné, j'ai découvert que le langage de base est en fait beaucoup plus simple que Java, mais sa syntaxe et sa sémantique sont si flexibles que vous pouvez créer de nouvelles constructions de langage comme lui, même sans fonction de macro. Depuis, je suis complètement passé à Scala pour tous mes projets Java, car cela me permet d'écrire sans trop de code standard.

J'aime Clojure, mais il y a des situations où la plate-forme a besoin de vous pour compiler en bytecode statique (Android, applets, ...) et pendant que vous pouvez le faire, dans Scala, c'est juste là.

Alors que Scala vous permet de résoudre de nombreux problèmes de manière fonctionnelle, je trouve souvent des problèmes où l'utilisation des cours semble plus naturelle. Cela rend les choses un peu plus complexes, mais loin des complexités et des douleurs du C ++.

Le plus gros point à retenir pour moi quand j'ai vraiment commencé à apprendre la langue était que je pouvais programmer juste en Java, juste sans le bruit (un peu comme lorsque vous démarrez Groovy), mais finalement vous voulez essayer de plonger plus profondément dans la puissance de la langue - elle grandit avec vous.

À propos de la question IDE: Après avoir utilisé Emacs pour tout, tous mes problèmes IDE ont disparu :-)

J'aime Scala pour de nombreuses raisons, mais il y en a une qui est souvent négligée: sa simplicité.

Scala n'est peut-être pas aussi simple que, disons, Oberon, mais il est beaucoup plus simple que certaines autres langues. La spécification du langage Scala fait ~ 160 pages, la spécification du langage Java est ~ 600 (juste le langage, pas la JVM ou les bibliothèques!), La spécification du langage ECMA-334 C # (dont AFAIK correspond à un sous-ensemble de Visual C # 2.0) est ~ 440 pages (c'est sans des trucs comme les compréhensions de requête LINQ, les expressions lambda, les méthodes d'extension, la co- et la contravariance génériques dynamic, les arguments optionnels avec des valeurs par défaut, les arguments de mots clés, var). Même la version actuelle d'ECMAScript 5.1 est plus volumineuse avec ~ 210 pages. Et bien sûr, mon propre langage "par défaut", Ruby, dont le brouillon ISO actuel pèse environ 310 pages, qui ne spécifie qu'un sous-ensemble presque inhabituellement minuscule de l'intersection de Ruby 1.8.6, 1.9.1 et 1.9.2.

Voici ce qui craint chez Scala:

• Le pointeur nul était une assez mauvaise idée pour commencer. Hoare l'a appelé son "erreur d'un milliard de dollars", mais Scala est encore pire. Il contient des objets nommés null, Null, None et Nil. null est pour l'interopérabilité avec Java. Null est la spécification DOM du W3C sous forme de pointeur nul, None est ce que null aurait dû être remplacé et Nil est un élément vide.

• Lorsque les constructions de langage s'avèrent être hacky, c'est généralement le programmeur qui est à blâmer et non la langue. Dans Scala, cependant, le langage principal contient déjà des classes de bibliothèque dont le seul comportement documenté est "Ceci est un hack". Tu ne le crois pas? Recherchez dans scaladoc scala.xml.Group.

• Enfin et surtout, Scala est mal documentée. Presque aucune des classes scala de la documentation officielle ne contient d'exemple de code. Scala est beaucoup plus difficile à apprendre que Java et nécessite des connaissances approfondies en informatique.

Pour éviter d'être confondu avec un Scala-hater, voici ce que j'aime à ce sujet:

• J'ai moins d'exceptions. Je n'ai jamais eu d'exception ClassCastException et très peu d'exceptions NullPointer lors de l'interaction avec Java.
• Le code est beaucoup plus court et plus concis que Java
• C'est un défi intellectuel. Java ressemble à un langage de bébé lorsqu'on le compare.

Scala est complexe. Pas question! Sa syntaxe est extrêmement flexible et peut être personnalisée de nombreuses manières (surtout les opérateurs / notation infixe) - et le système de type a plus de fonctionnalités différentes que tout autre langage que je connais.

Donc, les choses ne sont pas aussi droites que par exemple dans Haskell: Typeclasses pour les couvrir toutes.

Alors que Scala essaie de rassembler la programmation fonctionnelle, l'OO, la programmation procédurale et les bibliothèques java ainsi que ses propres idées, nous nous retrouvons finalement avec beaucoup de concepts qui semblent en quelque sorte aller dans le même sens:

• Valeurs implicites
• Fonctions implicites
• Existentials
• Caractères génériques
• Traits
• Interfaces
• Classes abstraites
• Classes de cas
• Types structurels
• Contraintes génériques
• Afficher les limites
• Types anonymes

Choisir parmi eux semble difficile au début et on peut facilement se demander si l'on a trouvé la bonne solution à un problème. Il est même facilement possible de produire des trucs hacky en abusant de l' implicitart.

Mais la chose intéressante est: Scala fonctionne. Il est parfois difficile de comprendre pourquoi (en particulier pour déterminer par quelles conversions implicites + héritage + ... certains objets ont des fonctionnalités X), mais vous n'avez pas à vous en préoccuper la plupart du temps.

Écrivez Scala aussi simple que possible et cela fonctionnera. Ne vous laissez pas dérouter par tout ce qui est possible et utilisez simplement ce dont vous avez besoin. Et si vous avez besoin de quelque chose, vous pouvez être sûr que Scala l'a en quelque sorte;)

Et mieux vous obtenez, plus vous pourrez personnaliser Scala avec des opérateurs, des implicits, des monades, une syntaxe funky ... et enfin obtenir quelque chose de proche d'une DSL qui résoudra parfaitement votre problème.

Après tout, vous avez toujours la possibilité d'utiliser Scala comme un bien meilleur Java avec une syntaxe plus propre et plus facile, une inférence de type et certaines fonctionnalités.

C'est un excellent langage qui est plus simple que Java à bien des égards.

La plupart des gens ne l'aimeront pas, programmeur Java ou non, pour les mêmes raisons que la plupart des gens, programmeurs ou non, n'aiment pas apprendre de nouveaux langages de programmation. Je soupçonne que la plupart des gens qui ont appris un langage de programmation n’ont même pas aimé l’apprendre.

Si vous craignez qu'un langage soit aussi compliqué que C ++, j'éviterais Clojure comme la peste. Pleurer que Scala est plus compliqué que Clojure est devenu l'argument de secours pour les gens qui sont complètement ignorants concernant une ou les deux langues.

Clojure a des macros, ce qui signifie que vous pouvez modifier la syntaxe du langage autant que vous le souhaitez, vous offrant non seulement "une myriade de façons différentes de faire les choses", mais un nombre presque infini de façons de faire les choses. Et aucune de cette nouvelle syntaxe que les programmeurs créent avec les macros ne sera documentée nulle part dans la spécification du langage.

"Mais nous pouvons éviter d'utiliser des macros ou réglementer celles qui sont autorisées dans notre code", dites-vous. Félicitations, vous devez maintenant "limiter artificiellement les fonctionnalités linguistiques que vous allez utiliser ou non", ce qui est exactement ce que les idiots babillards qui utilisent Clojure de Scala ont utilisé comme raison pour éviter Scala pour commencer.

J'aime vraiment les types plus granulaires de la bibliothèque Scala. Il semble que la nouvelle bibliothèque de collections ait été bien pensée. J'aime aussi la façon dont il réduit la quantité de code requise pour les classes simples et les concepts fonctionnels qu'il ajoute. Son inférence de type est également très utile. Cela ressemble à Java sans les roues d'entraînement. Après avoir utilisé C # pendant un certain temps, Scala se sent réellement comme un concurrent, Java étant toujours utile mais laissé pour compte.

En tant que programmeur Java, j'ai d'abord trouvé Scala intéressant. Cependant, après l'avoir essayé pendant un certain temps (et avoir rencontré presque tous les points positifs / négatifs déjà énumérés par d'autres), je me sentais très "meh" à son égard. Les améliorations de la langue sont compensées par la moindre disponibilité des ensembles d'outils. Je ne pouvais tout simplement pas trouver de raison déterminante de basculer. C'est bien, mais ce n'est pas "assez mieux" pour justifier un changement. N'a pas non plus ce facteur d'excitation subjective (comme Clojure semble le faire).