Il y a un problème général avec cette question en ce qu'elle est trop absolue. Cela n'a pas vraiment de sens de dire "la langue X est plus rapide que la langue Y". Un langage informatique lui-même n'est ni "rapide" ni "lent" car il s'agit simplement d'un moyen d'exprimer un algorithme. La véritable question devrait être de l'ordre de "pourquoi l'implémentation X1 du langage X est-elle plus rapide que l'implémentation Y1 du langage Y pour ce domaine de problème particulier?"
Certaines différences de vitesse vont certainement tomber de la langue elle-même car certaines langues sont plus faciles à implémenter certains domaines que d'autres. Mais une grande partie de ce qui rend une implémentation rapide n'est pas le langage. Par exemple, vous ne pouvez pas vraiment dire "Python est plus lent que Java" sans vous demander si vous parlez de CPython, IronPython ou PyPy. Cela est particulièrement vrai pour les langues qui utilisent une machine virtuelle, car la vitesse sera directement affectée par la qualité de la machine virtuelle.
En passant, je travaille avec un système qui, pour diverses raisons, ne peut pas utiliser JIT sur notre appareil avec une machine virtuelle JavaScript très populaire qui le prend normalement en charge. Cela signifie que notre JavaScript fonctionne beaucoup plus lentement que sur un PC avec un processeur similaire. Cette seule modification, qui n'est pas directement liée au langage lui-même, fait passer JavaScript de «quelques fois plus lent que C ++» à «d'ordre de grandeur plus lent que C ++» pour les tâches qui nous intéressent.
Tenez également compte du fait que les langues diffèrent dans leurs caractéristiques de performance de manière qui ne sont pas directement comparables. Trop de benchmarks traduisent simplement un programme de la langue A vers la langue B et ne tiennent pas compte du fait que les langues diffèrent dans les fonctionnalités qui sont rapides. (Vous pouvez le voir dans n'importe quelle comparaison de référence raisonnable, comme celles auxquelles vous liez, car elles ont souvent des notes comme "merci à tel ou tel pour m'avoir montré comment l'implémenter dans le langage Foo.)
Par exemple, prenez ce code Java:
for(int i=0;i<10;i++) {
Object o = new Object;
doSomething(o);
}
Il serait tentant de "réécrire" cela en C ++ et de comparer les temps d'exécution:
for(int i=0;i<10;i++) {
Object *o = new Object;
doSomething(o);
delete(o);
}
Le fait est que tout programmeur C ++ compétent verra immédiatement qu'en C ++, ce n'est pas le moyen le plus rapide de faire quelque chose. Vous pouvez facilement accélérer les choses en le modifiant pour qu'il soit plus approprié au C ++:
for(int i=0;i<10;i++) {
Object o;
doSomething(&o);
}
Le fait n'est pas que le C ++ peut être rapide mais plutôt que d'écrire des benchmarks pour comparer des langages est vraiment, vraiment difficile. Pour le faire correctement, vous devez être un expert dans les deux langues et écrire à partir de zéro dans les deux langues. Même alors, vous pouvez facilement vous heurter à des domaines où une langue excelle dans une tâche particulière. Par exemple, je peux écrire une version de Towers of Hanoi en C ++ qui fonctionnera plus rapidement que Java sur n'importe quel compilateur raisonnable. Je peux le faire en trichant essentiellement, en utilisant des modèles C ++, évalués au moment de la compilation (http://forums.devshed.com/c-programming-42/c-towers-of-hanoi-using-templates-424148.html)
Le point n'est pas que je pourrais dire que "C ++ est plus rapide que Java" parce que mon programme est revenu instantanément alors que la version Java a fonctionné pendant des minutes (et en espérant que personne n'a remarqué que mon programme a pris une demi-heure à construire.) Le fait est que pour cela varier cas étroit, C ++ est plus rapide. Pour d'autres cas étroits, ce pourrait être l'inverse. Ce n'est donc pas «C ++ est plus rapide», c'est «C ++ est plus rapide dans les cas où vous pouvez évaluer l'expression au moment de la construction à l'aide de modèles». Moins satisfaisant, mais vrai.
Les différences de vitesse dans les langues concernent principalement l'implémentation. Les langues compilées seront plus rapides que les langues interprétées. La compilation en code natif sera plus rapide que la compilation en code octet. Cela aura beaucoup plus d'effet que des questions comme si la langue est ou non typée statiquement. Et bien sûr, les bonnes implémentations vont être plus rapides que les mauvaises.
Et n'oubliez pas que les bons programmeurs vont produire du code plus rapidement que les mauvais programmeurs, souvent dans une mesure qui dépasse largement les différences de langue.