Quel est le gain de productivité supposé du typage dynamique? [fermé]

J'ai souvent entendu dire que les langages à typage dynamique sont plus productifs que les langages à typage statique. Quelles sont les raisons de cette réclamation? Ne s'agit-il pas simplement de travailler avec des concepts modernes tels que la convention sur la configuration, l'utilisation de la programmation fonctionnelle, des modèles de programmation avancés et l'utilisation d'abstractions cohérentes? Certes, l'encombrement est moindre car les déclarations de type souvent redondantes (par exemple en Java) ne sont pas nécessaires, mais vous pouvez également omettre la plupart des déclarations de type dans les langages à typage statique qui utilisent l'inférence de type, sans perdre les autres avantages du typage statique. Et tout cela est disponible pour les langages modernes typés statiquement comme Scala.

Alors, qu'y a-t-il à dire pour la productivité avec la frappe dynamique qui constitue réellement un avantage du modèle type lui-même?

Précision: je suis plus intéressé par les projets de grande / moyenne taille que par les piratages rapides. :-)

Je pense en fait que c'est un appel assez proche. Le typage dynamique et le typage statique ont leurs avantages.

Raisons pour lesquelles la frappe dynamique est plus productive:

• C'est plus concis - beaucoup de code passe-partout peut être éliminé si tout est dynamiquement typé - déclarations de type, logique de transtypage, etc. maintenir (puisque vous n'avez pas besoin de parcourir de nombreuses pages de code pour comprendre ce qui se passe)
• Des techniques plus faciles à "pirater" telles que la frappe de canard et la correction de singe peuvent vous donner des résultats très rapidement (bien que cela puisse vous dérouter plus tard ...)
• Plus interactive - le typage dynamique est sans doute plus approprié pour la programmation interactive, de type REPL, pour le prototypage rapide, le débogage en temps réel d'instances de programmes en cours d'exécution ou même le codage en direct.
• Les cas de test peuvent intercepter les erreurs d'exécution . En supposant que vous utilisiez TDD ou, à tout le moins, que vous disposiez d'une bonne suite de tests, cela devrait permettre de détecter tout problème de frappe dans votre code.
• Meilleur polymorphisme - les langages dynamiques sont potentiellement plus susceptibles d'encourager la création de fonctions polymorphes et d'abstractions, ce qui peut augmenter la productivité et la réutilisation de code. Clojure, par exemple, utilise beaucoup le polymorphisme dynamique dans ses nombreuses abstractions .
• Les prototypes - les modèles de données / objets basés sur des prototypes sont à mon avis plus puissants et flexibles que les hiérarchies d'héritage à typage statique. Les langages dynamiques sont plus susceptibles d'autoriser ou d'encourager une approche basée sur un prototype, le Javascript étant un bon exemple.

Raisons pour le typage statique étant plus productif:

• Une meilleure conception : être forcé de penser dès le départ aux types de valeurs de votre logiciel peut vous pousser à adopter des solutions plus propres et plus logiques. (Je dis can - il est toujours possible de concevoir un très mauvais code ...)
• Meilleure vérification au moment de la compilation - le typage statique peut permettre de détecter plus d’erreurs au moment de la compilation. C'est un énorme avantage et constitue sans doute la meilleure chose à propos des langages statiquement typés.
• Saisie automatique - le typage statique peut également fournir davantage d'informations à l'EDI, de sorte que la saisie automatique du code ou de la recherche de documentation est plus efficace.
• Décourage les hacks - vous devez conserver la discipline de type dans votre code, ce qui est susceptible d'être un avantage pour la maintenabilité à long terme.
• Inférence de type - dans certaines langues (par exemple, Scala), cela peut vous apporter un grand nombre des avantages de concision des langages dynamiques qui maintiendront toujours la discipline de type.

Ma conclusion moyenne (après plusieurs années d’expérience des deux côtés de la clôture) est que le typage dynamique peut être plus productif à court terme, mais qu’il devient finalement difficile à maintenir à moins d’avoir de très bonnes suites de tests et une discipline de test.

D'autre part, je préfère en fait les approches typées de manière statique, car je pense que les avantages de la correction et le support des outils vous offrent une meilleure productivité à long terme.

Avec les langages dynamiques, vous pouvez écrire du code de merde plus rapidement qu'avec un langage tapé.

Une fois que vous avez rapidement créé votre énorme pile d'éléments dynamiques, vous pouvez passer à un autre projet en toute sécurité sans vous soucier de la maintenance à long terme.

C'est un gain de productivité :)

Je plaisante, mais après avoir été impliqué dans un projet utilisant un «langage dynamique», j'ai été effrayé par la quantité de tests, documentations et conventions inutiles que vous devez gérer si vous voulez avoir un produit fonctionnel.
Et avec la joie de nombreuses erreurs d’exécution qui auraient pu être détectées lors de la compilation.
Oh, j'ai également oublié de parler de tous ces hacks et vaudous que la méta-programmation vous permet d'introduire dans votre code!

Le gain de productivité pourrait donc être un mythe pour les projets de taille moyenne à grande tout au long de leur vie.

Ce problème a aussi une vue théorique: un système de types statiques est essentiellement un prouveur de théorèmes spécialisé qui n’accepte le programme que s’il peut en prouver la correction de type. Tous les systèmes de types statiques rejettent certains programmes valides car aucun système de types statiques décidable n'est assez puissant pour prouver tous les programmes possibles corrects.

On pourrait soutenir que les programmes qui ne sont pas prouvables par un vérificateur de type statique sont des hacks et / ou un mauvais style, mais si vous possédez déjà un programme valide et que le vérificateur de type ne l'accepte pas, cela nuit certainement à votre productivité à court terme.

Dans certains cas, vous remarquerez peut-être que le vérificateur de types fait obstacle à des conteneurs génériques et à des co- / contravariances dans les arguments et les types de retour.

Un avantage que j'ai trouvé avec la plupart des langages dynamiques est qu'ils facilitent l'écriture de code plus générique. Il est beaucoup plus facile d'écrire à un niveau d'abstraction plus élevé lorsque vous n'avez pas à vous battre avec le système de caractères pour le faire.

Vous n'avez pas à y penser autant - écrire du code qui fait quelque chose de non trivial avec n'importe quel objet en Java est difficile et nécessite probablement une réflexion qui est typée de manière dynamique; avec quelque chose comme JavaScript, écrire une fonction qui fait quelque chose d'intéressant pour tous les objets est une seconde nature. Un exemple parfait serait une fonction que j'ai récemment écrite qui prend un objet et remplace toutes ses méthodes par des méthodes qui font la même chose mais déclenchent également un événement. Je ne sais pas comment aborder de telles choses en Java. Cependant, je ne suis pas sûr de savoir à quel point cela est dû aux systèmes de types et à d’autres différences de langage.

Cependant, j'ai récemment commencé à utiliser Haskell. Haskell me permet d’écrire du code abstrait générique aussi facilement que n’importe quel langage dynamiquement typé que j’ai utilisé. Mon exemple Java / JavaScript ci-dessus n'a aucun sens en Haskell car il n'a pas d'objets, de méthodes, d'événements ou même de nombreuses mutations, mais il est très facile d'écrire d'autres types de code générique.

En fait, Haskell peut écrire du code générique que les langages à typage dynamique ne peuvent pas; un exemple parfait est la readfonction qui est fondamentalement l'opposé de toString. Vous pouvez obtenir un type Intou un Doubletype quelconque (dans la mesure où il appartient à une classe de type). Vous pouvez même avoir polymorphes constantes , donc maxBoundpeut être le maximum Int, Double, Char... etc., Tout dépend de quel type il est censé être.

Ma théorie actuelle est que le gain de productivité lié à l’utilisation d’un langage dynamique est toujours comparé à des langages tels que Java avec des systèmes de types moins capables, plus détaillés et moins flexibles.

Cependant, même le système de typage de Haskell a quelques problèmes gênants que vous n'auriez pas dans un langage typé dynamiquement. Le plus gros problème qui me dérange, c'est la façon dont les chiffres sont traités. par exemple, vous devez modifier le système de types à utiliser length(d'une liste) en tant que double, ce avec quoi vous n'auriez aucun problème sans un système de types. Une autre chose gênante que j'ai rencontrée est de travailler avec Word8(un type non signé) et les fonctions attendues Int.

Donc, en fin de compte, ne pas avoir de système de types facilite l'écriture de code générique sans trop réfléchir et évite également les pièges gênants des systèmes de types. Vous n'avez jamais à combattre le système de typage dans un langage dynamique, mais vous ne pouvez pas vous en fier non plus.

Q: J'ai souvent entendu l'affirmation selon laquelle les langages à typage dynamique sont plus productifs que les langages à typage statique. Quelles sont les raisons de cette réclamation? "

Cela a des raisons historiques. Si vous remontez quelques décennies en arrière, les langages dynamiques étaient indiscutablement beaucoup plus productifs que les langages statiques (tout en étant beaucoup plus lents). Perl est clairement beaucoup plus productif que C si vous connaissez les deux et si la tâche à accomplir le permet. Mais au fil du temps, les langues se sont beaucoup empruntées et de nouvelles langues réduisent les écarts (en productivité et en performance).

Voici quelques points à considérer:

Ramassage des ordures : le ramassage des ordures augmente considérablement la productivité. Je crois que Java était le premier langage statique grand public avec GC. Auparavant, statique signifiait essentiellement la gestion manuelle de la mémoire. (Remarque: ici et dans la suite, je ne considère que les langues ordinaires. Il existe de nombreuses langues expérimentales et de niche qui fourniront des contre-exemples à chaque argument que je ferai.)

Sécurité de la mémoire : il s’agit d’une amélioration de la productivité qui vous évite de vous tirer une balle dans le pied. Avant les langages statiques "gérés" tels que Java, statique désignait généralement un accès direct à la mémoire. Le débogage fait également partie de la productivité, et un accès à la mémoire non sécurisé peut conduire à des bogues vraiment obscurs.

Systèmes de type encombrants. Avant l'introduction de types paramétrés (tels que les modèles ou les génériques) dans les langages statiques, les limitations des systèmes de types statiques étaient souvent un fardeau. Par exemple, en Java, vous deviez explicitement downcast chaque fois que vous sélectionniez un élément d'une collection. Donc, vous avez la surcharge syntaxique d'un casting et aucune sécurité de type. Compte tenu de l'omniprésence des collections dans la programmation, il s'agissait d'un inconvénient majeur.
Le fait de devoir déclarer le type de tout implique beaucoup de typage redondant, mais avec l'inférence de type moderne, cela peut être considérablement réduit.

Grande bibliothèque standard. Python a été annoncé comme "piles incluses" en raison de la grande bibliothèque standard. Ceci en comparaison avec C qui a une bibliothèque standard très minimaliste. Mais avec des plates-formes telles que Java et .net, une vaste bibliothèque standard devient standard et de nouveaux langages tels que Scala et F # en héritent "gratuitement".

Structures de données de première classe. Les langages dynamiques comme Perl et Python ont des structures de données de première classe intégrées, telles que des listes et des cartes, avec des raccourcis syntaxiques pratiques pour les opérations courantes. Comparé à cela, C n’a pas de collections intégrées à l’exception des tableaux de taille fixe.

Les fermetures et la syntaxe lambda - les langages dynamiques l'ont généralement depuis le début, mais les langages statiques l'ont adopté, plus récemment Java.

REPL la possibilité de tester rapidement les extraits de code de manière interactive est un avantage énorme. Toutefois, bien que les outils de l'EDI, comme la fenêtre "immédiate" de Visual Studio, les langages statiques puissent émuler cela dans une certaine mesure.

Outils avancés - en plus des points ci-dessus, où les langages statiques se rapprochent de la commodité des langages dynamiques, les éditeurs modernes tirent parti de l'analyse statique de manière à ce que les langages dynamiques peinent à correspondre. Par exemple, les éditeurs peuvent fournir des refactorisations automatiques sécurisées, ce qui est strictement impossible dans un langage dynamique.

En bout de ligne: historiquement, c'était vrai, mais aujourd'hui, la réponse est moins claire.

Q: Alors, qu'y a-t-il à dire pour la productivité avec le typage dynamique qui constitue réellement un avantage du modèle type lui-même?

Il est un peu difficile de séparer le modèle de frappe dynamique des langages dynamiques, mais à titre d'exemple, C # a adopté des fonctionnalités plus dynamiques au fil du temps, même s'il s'agit d'un langage statique. C'est vraiment une preuve d'avantage du modèle de type dynamique. Exemples:

Reflection La réflexion est fondamentalement une fonction de frappe dynamique. Vous inspectez les types d'objet au moment de l'exécution, au moment de la compilation. Lors de son introduction, il était plutôt mal vu, mais en C #, l’utilisation de la réflexion devient de plus en plus omniprésente, par exemple ASP.Net MVC utilise beaucoup la réflexion.

Attributs Les attributs sont un exemple de saisie dynamique. Vous pouvez ajouter des attributs arbitraires à une classe lors de la compilation, puis inspecter au moment de l'exécution (par réflexion) et manipuler des objets en fonction. Quelque chose comme MEP est fondamentalement un framework d'extension basé sur un modèle de type dynamique.

Linq to SQL, EF mv. Les différents transformateurs Linq inspectent les requêtes en tant qu’objets d’exécution et génèrent SQL à la volée. Cela ne devient pas plus dynamique que d'inspecter le code au moment de l'exécution. CodeDom est le revers de la médaille, où le code peut être généré à l'exécution

Roslyn Roslyn implémente fondamentalement eval, ce qui était autrefois considéré comme la caractéristique déterminante d'un langage réellement dynamique.

Dynamique Le dynamictype-est la fonctionnalité la plus explicitement dynamique de C # et a pour objectif de rendre l'interaction avec des objets externes et des langages plus simples et plus productifs. Mais il est également utilisé dans Asp.net MVC pour plus de commodité.

L'avantage de toutes les caractéristiques ci-dessus montre que le modèle dynamique présente des avantages certains, même dans un langage statique avec des types paramétrés, des types structurels et des inférences de types.

L’ensemble des fonctionnalités du langage moderne est si vaste que la dactylographie statique ou dynamique n’a pas beaucoup de poids.

La règle est la suivante: plus vos fonctionnalités linguistiques sont bonnes, plus votre code est court. C'est assez simple. Java montre à quel point le typage statique peut très mal tourner, ce qui donne à ses adversaires beaucoup à se nourrir. Les fonctionnalités de langage mal conçues ont généralement un coût, et le typage statique en Java est d’une part obligatoire (sinon la plupart des gens ne l’utiliseraient probablement même pas) et d’autre part, mal exécuté.
C'est pourquoi, en comparaison, la plupart des langages dynamiques brillent, même si je dirais que PHP ne vous rend pas la vie meilleure dans le grand total (du moins jusqu'à récemment), en raison de nombreuses autres bizarreries sans rapport avec les systèmes de types.

D'autre part, vous avez beaucoup de langages avec des systèmes de types expressifs qui ne vous gênent pas et qui ne sont même pas obligatoires. Et certains d'entre eux permettent même d'incorporer du code non typé, chaque fois que vous devez échapper au système de types.

Personnellement, j'utilise haXe, un langage avec inférence de types, sous-typage nominal et structurel, code non typé optionnel, types de fonction de première classe, types de données algébriques et macros lexicales (pas tout à fait mûr mais extrêmement puissant), tout en évitant la syntaxe arcane. Après avoir utilisé haXe pendant environ 3 ans maintenant, je suis arrivé à une conclusion simple:

La programmation devient beaucoup plus facile lorsque votre langue ne vous enferme pas dans des choix religieux concernant des paradigmes, mais tente simplement d’être un bon outil. Un certain nombre de langages statiques et dynamiques et de langages mixtes réussissent. Certains sont faciles à apprendre, les plus difficiles à maîtriser.
Leur puissance provient de la manière dont leurs caractéristiques individuelles peuvent être composées pour créer facilement des solutions simples à des problèmes complexes. Cela exclut une certaine orthogonalité qui ne peut être atteinte que par un équilibre délicat d'inclusion ou d'omission de toutes les caractéristiques linguistiques explorées jusqu'à présent. Si vous essayez d'ajouter du texte statique à Ruby, vous le paralyserez, si vous essayez de l'éloigner de Haskell, vous écrasez-le. Contrairement à cela: si vous l'enleviez à C, les gens le remarqueraient à peine et si vous l'enleviez à Java, certains pourraient vous remercier.

D'après mon expérience personnelle, je peux vous dire ceci: j'aime Ruby. Cela a élargi mes horizons et ma façon de concevoir les systèmes. IMHO, il devrait être utilisé pour enseigner aux gens la programmation en premier lieu. C'est discret, puissant, concis, amusant. Je comprends pourquoi quelqu'un venant d'une langue orthodoxe va en profiter.
Cependant, à long terme, le typage statique permet de reporter le travail à l’analyseur statique et, avec l’inférence de type, c’est gratuit. Il en résulte un code plus facile à gérer et souvent plus rapide.

Mais encore une fois, le typage statique seul ne peut rien faire. C'est une question de combinaison. Je pense que quelque part entre F #, Scala, Nemerle, OCaml ou haXe, vous pouvez trouver votre propre optimum. Mais cela dépend en définitive de vous, car le langage devrait vous permettre d’intégrer vos pensées sans effort, au lieu de vous obliger à les plier. Et après tout, rien ne rapporte plus de gain de productivité que si la programmation est amusante.

Personnellement, la seule raison pour laquelle le typage dynamique aiderait serait si vous êtes un dactylographe très lent ou si vous créez des fonctions / méthodes / whatevers géants avec lesquels il est difficile de naviguer. Vous devez également entrer dans le problème des tests unitaires. Les types dynamiques nécessitent (sauf si vous aimez écrire du code erroné) des tests unitaires vigoureux (pour vous assurer que vos types dynamiques ne explosent pas de manière inattendue (la variable est principalement du canard, mais peut-être accidentellement parfois)). La statique va essayer beaucoup plus dur pour empêcher cela (Et oui, vous pouvez argumenter en faveur de tests unitaires rigoureux)

Je pense d’abord que vous devez définir la "productivité". Que signifie "productivité" et inclut-il?

Si «plus productif» signifie que vous voulez écrire moins de lignes de code pour implémenter la même fonctionnalité, alors oui, les langages de programmation à typage dynamique sont plus «productifs» que les langages à typage statique.

Toutefois, si vous prenez également en compte le temps consacré au débogage et à la correction des bogues, les langages de frappe dynamique risquent de ne pas être aussi productifs, car les langages de frappe dynamique ont tendance à pousser la vérification des erreurs vers l'exécution au lieu des langages de frappe statique peut effectuer des vérifications d’erreur au moment de la compilation. Comme il est communément admis que plus un bogue est détecté tardivement, plus il est coûteux de le réparer. Par conséquent, le code de frappe dynamique peut donner une productivité généralement égale, voire inférieure, à celle du code de frappe statique.

Le gros avantage de la frappe dynamique est la productivité.

En plus du typage dynamique (paramètres par défaut, dictionnaires en tant que types intégrés, etc.), Python, Ruby, etc. ont de nombreux autres avantages pour la productivité. L’effet cumulatif sur la productivité du programmeur est impressionnant.

Les pénalités en termes de rapidité (ou d’absence de ressources!) Et de consommation de ressources ne sont pas aussi graves que prévu et, dans la plupart des cas, sont plus que compensées par la rapidité et la flexibilité du développement.

Il y a un (très vieux!) Du papier sur le sujet ici. Il s’agit de l’une des rares études bien menées sur la productivité des programmeurs et bon nombre des conclusions sont toujours valables.

Ce qui serait (probablement) différent si l’étude devait être menée aujourd’hui: -

1. Les machines virtuelles Java ont été améliorées au delà de la reconnaissance.
2. Les IDE modernes auraient amélioré la productivité des codeurs C ++ et Java, mais n'auraient eu que très peu d'impact sur les langages de script.
3. C # serait inclus et probablement dans le même parc que Java mais légèrement mieux.

Le message est donc que si les performances ne sont pas un problème vraiment sérieux, les langages dynamiques augmenteront votre productivité.