web-dev-qa-db-fra.com

Études de langues typées de manière dynamique vs statiquement

Existe-t-il des études réalisées sur l'efficacité des langues statistiques et dactylographiques dynamiquement?

En particulier:

  • Mesures de productivité du programmeur
  • Taux de défaut

Incluant également les effets de l'utilisation ou non des tests unitaires.

J'ai vu beaucoup de discussions sur les mérites de chaque côté, mais je me demande si quelqu'un a fait une étude sur elle.

productivitycomparisontype-systemsdynamic-typingstatic-typing
71
Winston Ewert

Certaines ont suggéré de lire:

Pas exactement sur la typographie statique, mais connexe:

Quelques articles intéressants ou essais sur le sujet ou sur l'analyse statique des programmes en général:

Et pour ceux qui se demanderaient de quoi il s'agit de:

Cependant, je doute de ceux-ci avec une réponse directe, car ils ne font pas exactement l'étude que vous recherchez. Ils seront des lectures intéressantes cependant.

personnellement , je considère fermement que la typage statique sur la typographie dynamique facilite la détection de bugs. Je passe beaucoup trop de type à la recherche de fautes de frappe et d'erreurs mineures comme celles-ci dans JavaScript ou même Ruby code. Et quand il s'agit de voir que la typage dynamique vous donne un coup de pouce de productivité, je pense que la plupart du temps s'éloigne à l'outillage. Si les langues typées statiquement ont les bons outils pour permettre la recompilation des antécédents et fournir une interface REPL, vous bénéficiez des avantages des deux mondes. Scala fournit ceci par exemple, ce qui facilite l'apprentissage et le prototype de la console interactive, mais vous donne les avantages de la saisie statique (et d'un système de type plus fort que beaucoup d'autres langues, ML -Lavres de côté). De même, je ne pense pas avoir une perte de productivité en utilisant Java ou C++ (en raison de la typographie statique), à ​​condition que j'utilise un IDE qui m'aide. Lorsque je revenons à coder uniquement avec des configurations simples (éditeur + compilateur/interprète), il semble que des langues plus encombrantes et dynamiques semblent plus faciles à utiliser. Mais tu chasse toujours des insectes. Je suppose que les gens diraient que le problème de l'outillage est un argument réversible, comme si vous étiez meilleur pour les langages dynamiques, la plupart des bogues et des fautes de frappe seraient désignés au fil de codage, mais qui reflète la faille du système à mon avis. Néanmoins, je prototype habituellement dans Jruby et codera en Java plus tard, la plupart des choses que je fais.

AVERTISSEMENT: Certains de ces liens ne sont pas fiables, et certains traversent des portails de diverses sociétés de calcul utilisant des accès à la taxe sur les membres. Désolé, j'ai essayé de trouver plusieurs liens pour chacun de ceux-ci, mais ce n'est pas aussi bon que j'aimerais que ce soit.

43
haylem

Juste hier, j'ai trouvé cette étude: Le test unitaire n'est pas suffisant. Vous avez besoin d'un typing statique aussi.

Fondamentalement, l'auteur a utilisé un outil capable de convertir automatiquement un projet d'une langue de frappe non statique en une typographie statique (Python à Haskell)

Ensuite, il a sélectionné un certain nombre de projets open source Python projets qui incluaient également une quantité raisonnable d'unités de test et les convertit automatiquement vers HASKELLL.

La traduction to Haskell a révélé une série d'erreurs liées au type des variables: les erreurs n'étaient pas découvertes par les unités de test.

19
PBrando

Voici un point de départ:

Le document conteste la sagesse couramment reçue qui, tous les autres étant égaux, les programmeurs écrivent le même nombre de lignes de code par heure quelle que soit la langue. En d'autres termes, le papier devrait servir de preuves empiriques à soutenir la productivité mécanique (lignes du code écrit) non une bonne mesure de la productivité fonctionnelle et doit au moins être normalisé par langue.

6
Pi Delport

Voici quelques-uns:

  • Stefan Hanenberg. 2010. Expérience sur les systèmes de type statique et dynamique: Doutes sur l'impact positif des systèmes de type statique sur le temps de développement. Dans les procédures de la Conférence internationale d'ACM sur les systèmes de programmation orientés objet Langues et applications (OOPSLA '10). ACM, New York, NY, USA, 22-35. DOI = 10.1145/1869459.1869462 http://di.acm.org/10.1145/1869459.1869462

  • Daniel P. Delaory, Charles D. Knutson, Scott Chun, "Les langages de programmation affectent la productivité? Une étude de cas utilisant des données de projets open source", FLOSS, PP.8, premier atelier international sur les tendances émergentes en matière de recherche et de développement en soi '07: Ateliers ICSE 2007), 2007

  • Daly, m.; SAZAWAL, V., Foster, J .: Travailler en cours: une étude empirique de la typographie statique dans Ruby, de l'atelier sur l'évaluation et la convivialité des langages et des outils de programmation (Plateau) à la station 2009.

  • Lutz Prechelt et Walter F. Tichy. 1998. Une expérience contrôlée pour évaluer les avantages de la procédure Vérification du type d'argument. IEEE trans. Softw. Fra. 24, 4 (avril 1998), 302-312. DOI = 10.1109/32.677186 http://dx.di.org/10.1109/32.677186

0
Lorin Hochstein

Honnêtement, je ne pense pas que la typographie dynamique statique vs est la vraie question.

Je pense qu'il y a deux paramètres qui devraient venir en premier:

  • le niveau d'expertise dans la langue: plus vous êtes expérimenté, plus vous savez sur les "gotchas" et plus vous êtes susceptible de les éviter/les suivre facilement. Ceci est également vrai sur l'application/programme particulière que vous travaillez sur
  • test: J'adore la typographie statique (enfer j'aime la programmation en C++: p) Mais il peut tellement qu'un compilateur/analyseur statique puisse faire pour vous. Il est tout simplement impossible d'avoir confiance en un programme sans l'avoir testé. Et je suis tout pour des tests flous (le cas échéant), car vous ne pouvez pas penser à toutes les combinaisons d'entrée possibles.

Si vous êtes à l'aise dans la langue, vous écrivez du code et vous allez suivre facilement des bugs.

Si vous écrivez du code découplé et testez de manière approfondie chaque fonctionnalité, vous produirez un code bien poli et vous serez donc productif (car vous ne pouvez donc pas être qualifié de productivité si vous n'évaluez pas la qualité du produit, pouvez-vous? )

Je déciderais donc que le débat statique vs dynamique en ce qui concerne la productivité est tout à fait discutable ou au moins fortement remplacé par d'autres considérations.

0
Matthieu M.