Java compiler vitesse vs Scala compiler vitesse

il y a deux aspects à la (manque de) vitesse pour le compilateur Scala.

1. Plus grand démarrage de frais généraux

   • Scalac lui-même se compose d'un grand nombre de classes qui doivent être chargés et JIT-compilé

   • Scalac doit rechercher dans classpath tous les paquets et fichiers racine. Selon la taille de votre classpath cela peut prendre de une à trois extra deuxième.

   dans l'ensemble, attendez-vous à un temps de démarrage de scalac de 4-8 secondes, plus long si vous l'exécutez la première fois pour que les caches disque ne soient pas remplies.

   la réponse de Scala aux frais généraux de démarrage est d'utiliser fsc ou de faire de la construction continue avec sbt. IntelliJ doit être configuré pour utiliser l'une ou l'autre des options, sinon ses frais généraux, même pour les petits fichiers, sont déraisonnablement importants.

2. plus lent vitesse de compilation. Scalac gère environ 500 à 1000 lignes/ sec. Javac gère environ 10 fois ça. Il y a plusieurs raisons à cela.

   • l'inférence de Type est coûteuse, en particulier si elle implique une recherche implicite.

   • Scalac doit faire une vérification de type deux fois; une fois selon les règles de Scala et une deuxième fois après l'effacement selon les règles de Java.

   • En plus de la vérification de type, il y a environ 15 étapes de transformation pour passer de Scala à Java, qui prennent toutes du temps.

   • Scala génère typiquement beaucoup plus de classes par taille de fichier donnée que Java, en particulier si les idiomes fonctionnels sont largement utilisés. La génération du Bytecode et l'écriture de classe prennent du temps.

   d'un autre côté, un programme Scala de 1000 lignes peut correspondre à un programme Java de 2-3K lignes, donc certains de la vitesse plus lente lorsqu'on compte en lignes par seconde doit être équilibrée par rapport à plus de fonctionnalités par ligne.

   nous travaillons sur des améliorations de vitesse (par exemple en générant des fichiers de classe en parallèle), mais on ne peut pas s'attendre à des miracles sur ce front. Scalac ne sera jamais aussi rapide que javac. Je pense que la solution résidera dans la compilation de serveurs comme fsc en conjonction avec une bonne analyse de dépendances de sorte que seul l'ensemble minimal de fichiers doit être recompilé. Nous travaillons sur ce, trop.

vous devez savoir que la compilation Scala prend au moins un ordre de grandeur plus long que Java. Les raisons en sont les suivantes:

1. conventions de nommage (un fichier XY.scala ne doit pas nécessairement contenir une classe appelée XY et peut contenir plusieurs classes de premier niveau). le compilateur peut donc avoir à rechercher d'autres fichiers sources pour trouver un identificateur de classe/trait/objet donné.
2. Implicits-l'utilisation intensive d'implicits signifie que le compilateur doit rechercher toute conversion implicite dans le champ d'application pour une méthode donnée et les classer pour trouver la "bonne". ( c.-à-d. que le compilateur a un domaine de recherche massivement augmenté lors de la localisation d'une méthode. )
3. le système de type-le système de type scala est beaucoup plus compliqué que Java et prend donc plus de temps CPU.
4. l'inférence de Type - l'inférence de type est gourmand en ressources et une emploi que javac n'a pas besoin de faire du tout
5. scalac comprend un simulateur 8 bits d'une station de combat entièrement armée et opérationnelle, visible à l'aide de la combinaison de touches magiques CTRL-ALT-F12 pendant la phase de compilation GenICode .

la meilleure façon de faire Scala est avec IDEA et SBT. Configurez un projet SBT élémentaire (ce qu'il fera pour vous, si vous voulez) et lancez-le en mode de compilation automatique (commande ~compile ) et quand vous sauvegarderez votre projet, SBT le recompilera.

vous pouvez également utiliser le plug-in SBT pour IDEA et attacher une action SBT à chacune de vos Configurations D'exécution. Le plug-in SBT vous offre également une console SBT interactive au sein D'IDEA.

dans les deux cas (SBT en cours d'exécution externe ou SBT plug-in), SBT reste en cours d'exécution et donc toutes les classes utilisées dans la construction de votre projet se "warmed up" et JIT-ed et le démarrage overhead est éliminé. De plus, SBT ne compile que les fichiers sources qui en ont besoin. C'est de loin le moyen le plus efficace de construire des programmes Scala.

Les dernières révisions de Scala-IDE (Eclipse) sont beaucoup mieux atmanaging compilation incrémentielle.

voir " Quel est le meilleur système de construction Scala? " pour plus d'.

l'autre solution est d'intégrer FSC - Fast offline compiler pour le langage Scala 2 - (comme illustré dans ce blog post ) comme un constructeur dans votre IDE.

mais pas dans directement éclipse cependant, comme Daniel Spiewak mentions dans les commentaires:

vous ne devriez pas utiliser FSC dans Eclipse directement, ne serait-ce que parce Qu'Eclipse utilise déjà FSC sous la surface.

FSC est essentiellement une couche mince sur le dessus du compilateur résident qui est précisément le mécanisme utilisé par Eclipse pour compiler les projets Scala.

enfin, comme Jackson Davis 151920920" me rappelle dans les commentaires:

sbt (Simple Outil de construction) comprennent également une sorte de "surplus" de la compilation (par le biais de déclenché "l'exécution 151920920" ), même si elle n'est pas parfait , et amélioration de la compilation incrémentielle est dans le travailler pour la prochaine version 0.9 sbt.

Use fsc - c'est un compilateur Scala rapide qui s'assoit comme tâche de fond et n'a pas besoin de charger tout le temps. Il peut réutiliser l'instance de compilateur précédente.

Je ne suis pas sûr que le plugin Scala de Netbeans supporte fsc (La documentation le dit), Mais je n'ai pas pu le faire fonctionner. Essayez les constructions nocturnes du plugin.

vous pouvez utiliser le plugin JRebel qui est gratuit pour Scala. Donc vous pouvez en quelque sorte "développer dans le débogueur" et JRebel rechargeait toujours la classe changée sur place.

j'ai lu une déclaration quelque part par Martin Odersky lui-même où il dit que les recherches d'implicits (le compilateur doit s'assurer qu'il n'y a pas plus d'un implicite simple pour la même conversion pour éliminer les ambiguïtés) peut garder le compilateur occupé. Donc ça pourrait être une bonne idée de gérer implicites avec soin.

si elle ne doit pas être 100% Scala, mais aussi quelque chose de similaire, vous pourriez donner Kotlin un essai.

-- Oliver

je suis sûr que ce sera voté à la baisse, mais une rotation extrêmement rapide n'est pas toujours propice à la qualité ou à la productivité.

prendre le temps de réfléchir plus attentivement et d'exécuter moins de micro-cycles de développement. Un bon code Scala est plus dense et plus essentiel (c'est-à-dire exempt de détails fortuits et de complexité). Il demande plus de réflexion et qui prend du temps (au moins au début). Vous pouvez bien progresser avec moins de cycles de code / test / débogage qui sont individuellement un peu plus long et encore d'améliorer votre productivité et la qualité de votre travail.

en bref: rechercher un plan de travail optimal mieux adapté à Scala.