Langues de type dynamique par rapport aux langues de type statique

les systèmes de type statique cherchent à éliminer certaines erreurs statiquement, en inspectant le programme sans l'exécuter et en essayant de prouver la solidité à certains égards. Certains systèmes sont capables d'attraper plus d'erreurs que les autres. Par exemple, C# peut éliminer les exceptions du pointeur null lorsqu'il est utilisé correctement, alors que Java n'a pas cette puissance. Twelf a un système de type qui en fait garantit que les preuves se termineront , "résoudre" le problème d'arrêt .

cependant, aucun système de type n'est parfait. Afin d'éliminer une classe particulière d'erreurs, ils doivent également rejeter certains programmes parfaitement valides qui violent les règles. C'est pourquoi Twelf ne résout pas vraiment le problème de l'arrêt, il l'évite simplement en jetant un grand nombre de preuves parfaitement valides qui se terminent de manière étrange. De même, le système de type Java rejette L'implémentation PersistentVector de Clojure en raison de son utilisation d'hétérogènes tableau. Il fonctionne à l'exécution, mais le système de type ne peut pas le vérifier.

pour cette raison, la plupart des systèmes de type fournissent des" échappées", des moyens pour outrepasser le vérificateur statique. Pour la plupart des langues, ils prennent la forme de casting, bien que certains (comme C# et Haskell) aient des modes entiers qui sont marqués comme "dangereux".

subjectivement, j'aime la dactylographie statique. Mis en œuvre correctement (conseil: pas Java), un système de type statique peut être une aide énorme en éliminer les erreurs avant qu'elles ne détruisent le système de production. Les langages dactylographiés dynamiquement ont tendance à nécessiter plus de tests unitaires, ce qui est fastidieux dans le meilleur des cas. En outre, les langages statiquement typés peuvent avoir certaines caractéristiques qui sont soit impossibles, soit dangereuses dans les systèmes de type dynamique ( conversions implicites ressort à l'esprit). Tout est question d'exigences et de goûts subjectifs. Je ne construirais pas plus la prochaine éclipse dans Ruby que je tenterais d'écrire une sauvegarde script dans assembler ou patcher un noyau en utilisant Java.

Oh, et les gens qui disent que " x typage est 10 fois plus productifs que y taper" sont tout simplement souffler de la fumée. La dactylographie dynamique peut " se sentir "plus rapidement dans de nombreux cas, mais elle perd du terrain une fois que vous essayez réellement de faire votre application de fantaisie run . De même, la dactylographie statique peut sembler être le filet de sécurité parfait, mais un coup d'oeil à certains des plus les définitions de type génériques compliquées en Java envoient la plupart des développeurs se dépêchant pour les œillères. Même avec les systèmes de type et la productivité, il n'y a pas de solution miracle.

note finale: ne vous souciez pas des performances en comparant la saisie statique avec la saisie dynamique. Les JITs modernes comme V8 et TraceMonkey se rapprochent dangereusement des performances linguistiques statiques. En outre, le fait que Java compile réellement vers le bas à un langage intermédiaire dynamique inhérente devrait être un indice que pour dans la plupart des cas, la dactylographie dynamique n'est pas l'énorme tueur de performance que certains prétendent être.

Eh bien, les deux sont très, très très très mal compris et aussi deux choses complètement différentes. qui ne sont pas mutuellement exclusifs .

types Statiques sont une restriction de la grammaire de la langue. On pourrait dire que les langages statiquement typés ne sont pas sans contexte. La simple vérité est qu'il devient incommode d'exprimer un langage sainement dans des grammaires libres de contexte qui ne traitent pas toutes ses données simplement comme des vecteurs de bits. Statique les systèmes de type font partie de la grammaire de la langue s'il y en a, ils la restreignent simplement plus qu'une grammaire libre de contexte pourrait, les vérifications grammaticales se produisent donc en deux passes au-dessus de la source vraiment. Les types statiques correspondent à la notion mathématique de la théorie des types, la théorie des types en mathématiques restreint simplement la légalité de certaines expressions. Comme, je ne peux pas dire 3 + [4,7] en mathématiques, c'est à cause de la théorie des types.

types Statiques sont donc pas un moyen d'empêcher que des les erreurs ' d'un point de vue théorique, elles sont une limitation de la grammaire. En effet, à condition que+, 3 et les intervalles aient les définitions théoriques habituelles de l'ensemble, si nous supprimons le système de type 3 + [4,7] a un résultat assez bien défini qui est un ensemble. les "erreurs de type d'exécution" n'existent pas en théorie, l'utilisation pratique du système de type est d'empêcher les opérations qui pour les êtres humains n'aurait aucun sens. Les opérations ne sont encore que le déplacement et la manipulation de bits de cours.

le hic, c'est qu'un système de type ne peut pas décider si de telles opérations vont se produire ou non s'il serait autorisé à fonctionner. Comme dans, séparez exactement l'ensemble de tous les programmes possibles dans ceux qui vont avoir une 'erreur de type', et ceux qui ne le sont pas. Il ne peut faire que deux choses:

1: prouver que des erreurs de type vont se produire dans un programme

2: prouver qu'ils ne vont pas se produire dans un programme

on dirait que je me contredis. Mais ce qu'un vérificateur de type C ou Java fait est qu'il rejette un programme comme 'ungrammatical', ou comme il l'appelle 'erreur de type' si il ne peut pas réussir à 2. Il ne peut pas prouver qu'ils ne vont pas se produire, cela ne signifie pas qu'ils ne vont pas se produire, cela signifie simplement qu'il ne peut pas le prouver. Il se pourrait très bien qu'un programme qui n'aura pas une erreur de type est rejetée simplement parce qu'il ne peut pas être prouvé par l' compilateur. Un exemple simple étant if(1) a = 3; else a = "string"; , sûrement puisque c'est toujours vrai, la branche else ne sera jamais exécutée dans le programme, et aucune erreur de type ne se produira. Mais il ne peut pas prouver ces cas, d'une manière générale, il est donc rejetée. C'est la principale faiblesse de beaucoup de langues statiquement dactylographiées, en vous protégeant contre vous-même, vous êtes nécessairement aussi protégé dans les cas où vous n'en avez pas besoin.

, Mais, contrairement à la croyance populaire, il ya aussi typé statiquement les langues qui fonctionnent selon le principe 1. Ils rejettent simplement tous les programmes dont ils peuvent prouver qu'ils vont causer une erreur de type, et passent tous les programmes dont ils ne peuvent pas. Il est donc possible qu'ils permettent des programmes qui ont des erreurs de type, un bon exemple étant le Racket dactylographié, c'est hybride entre le typage dynamique et statique. Et certains diront que vous obtenez le meilleur des deux mondes dans ce système.

un autre avantage du typage statique est que les types sont connus au moment de la compilation, et ainsi le compilateur peut utiliser ceci. Si nous en Java faisons "string" + "string" ou 3 + 3 , les deux + dans le texte à la fin représentent une opération et une donnée complètement différente, le compilateur sait quoi choisir parmi les types seuls.

Maintenant, je vais faire une déclaration controversée ici, mais garder avec moi: 'typage dynamique" n'existe pas .

semble très controversé, mais il est vrai, dynamiquement tapé les langues sont d'un point de vue théorique untyped . Ce sont juste des langues statiquement typées avec un seul type. Ou tout simplement, ce sont des langues qui sont en effet grammaticalement générées par une grammaire libre de contexte dans la pratique.

pourquoi n'en ont-ils pas? Parce que chaque opération est définie et autorisée sur chaque opérant, qu'est-ce qu'une "erreur de type d'exécution" exactement? Il s'agit d'un exemple purement théorique d'un effet secondaire . Si faire print("string") qui imprime une chaîne est une opération, alors length(3) aussi , le premier a l'effet secondaire d'écrire string à la sortie standard, le second simplement error: function 'length' expects array as argument. , c'est tout. D'un point de vue théorique, un langage dynamiquement dactylographié n'existe pas. Ils sont non typé

D'accord, l'avantage évident du langage 'dynamiquement typé' est la puissance expressive, un système de type n'est rien d'autre qu'un limitation du pouvoir expressif. Et en général, les langages avec un système de type auraient en effet un résultat défini pour toutes les opérations qui ne sont pas autorisées si le système de type était simplement ignoré, les résultats n'auraient tout simplement pas de sens pour les humains. Beaucoup de langues perdent leur exhaustivité de Turing après avoir appliqué un système de type.

l'inconvénient évident est le fait que les opérations peuvent se produire qui produirait des résultats qui sont insensés pour les humains. Pour se prémunir contre cette, les langages dactylographiés dynamiquement redéfinissent généralement ces opérations, plutôt que de produire ce résultat absurde ils le redéfinissent à avoir l'effet secondaire d'écrire une erreur, et peut-être arrêter le programme tout à fait. Ce n'est pas du tout une "erreur", en fait, la spécification de la langue implique généralement cela, c'est autant le comportement de la langue que l'impression d'une chaîne de caractères d'une perspective théorique. Les systèmes de Type forcent ainsi le programmeur à raisonner sur le flux du code pour s'assurer que cela ne se produise pas. Ou en effet, la raison de sorte qu'il does arrive peut également être pratique dans certains points pour le débogage, montrant que ce n'est pas une "erreur" du tout, mais une propriété bien définie du langage. En effet, le seul résidu de la "dactylographie dynamique" que possèdent la plupart des langues se protège contre une division par zéro. C'est ce qu'est le typage dynamique, il n'y a pas de types, il n'y a pas plus de types que Zéro est un type différent que tous les autres nombres. Ce que les gens appellent un "type" est juste une autre propriété d'une donnée, comme la longueur d'un tableau, ou le premier caractère d'une chaîne. Et de nombreux langages dactylographiés dynamiquement vous permettent également d'écrire des choses comme "error: the first character of this string should be a 'z'" .

une autre chose est que les langages dactylographiés dynamiquement ont le type disponible à l'exécution et peuvent généralement le vérifier et traiter avec lui et décider à partir de lui. Bien sûr, en théorie, ce n'est pas différent d'accéder au premier char d'un tableau et de voir ce que c'est. En fait, vous peut faire votre propre c dynamique, il suffit d'utiliser un seul type comme long long int et d'utiliser les 8 premiers bits de celui-ci pour stocker votre 'type' et écrire des fonctions en conséquence qui vérifient pour elle et effectuer float ou integer addition. Vous avez un langage statiquement typé, avec un type, ou d'un langage dynamique.

dans la pratique, tout cela montre que les langages statiquement typés sont généralement utilisés dans le contexte de l'écriture de logiciels commerciaux, alors que les langages dynamiquement typés ont tendance à être utilisés dans les contexte de résolution de certains problèmes et d'automatisation de certaines tâches. L'écriture de code dans des langages statiquement dactylographiés prend tout simplement beaucoup de temps et est lourde parce que vous ne pouvez pas faire des choses que vous savez vont se révéler bien, mais le système de type vous protège toujours contre vous-même pour les erreurs que vous ne faites pas. Beaucoup de codeurs ne se rendent même pas compte qu'ils font cela parce que c'est dans leur système mais quand vous codez dans les langues statiques, vous travaillez souvent autour du fait que le système de type ne vous laissera pas faire des choses qui ne peuvent pas aller mal, parce qu'il ne peut pas prouver qu'il ne vous tromperez pas.

comme je l'ai noté, "statically typed" signifie en général cas 2, coupable jusqu'à preuve de l'innocence. Mais certaines langues, qui ne dérivent pas leur système de type de la théorie des types du tout utilisent la règle 1: Innocent jusqu'à preuve du contraire, qui pourrait être l'hybride idéal. Donc, peut-être que le Racket tapé à la machine est pour toi.

aussi, bien, pour un exemple plus absurde et extrême, je suis en train de mettre en œuvre un langage où les "types" sont vraiment le premier caractère d'un tableau, ce sont des données, des données du 'type', du 'type', qui est lui-même un type et un datum, le seul datum qui se présente comme un type. Les Types ne sont pas finis ou limités statiquement, mais de nouveaux types peuvent être générés sur la base des informations d'exécution.

peut-être le plus grand "avantage" de la dactylographie dynamique est la courbe d'apprentissage moins profonde. Il n'y a pas de système de type à apprendre et pas de syntaxe non triviale pour les cas de coin comme les contraintes de type. Cela rend la dactylographie dynamique accessible à beaucoup plus de gens et faisable pour beaucoup de gens pour qui des systèmes statiques sophistiqués sont hors de portée. Par conséquent, le typage dynamique s'est développé dans les contextes de l'éducation (par exemple Scheme/Python au MIT) et des langages spécifiques aux domaines pour non programmeurs (par exemple Mathematica ). Les langages dynamiques se sont également imposés dans des niches où ils n'ont que peu ou pas de concurrence (par exemple Javascript).

les langues dynamiquement dactylographiées les plus concises (par exemple Perl, APL, J, K, Mathematica ) sont spécifiques à un domaine et peuvent être beaucoup plus concises que les langues statiquement dactylographiées les plus concises (par exemple OCaml ) dans les niches où elles ont été conçues . pour.

les principaux inconvénients de la dactylographie dynamique sont:

• " Run-time type errors.

• peut être très difficile ou même pratiquement impossible à atteindre le même niveau de justesse et nécessite beaucoup plus de tests.

• Aucun document vérifié par le compilateur.

• mauvais rendement (généralement à l'exécution mais parfois à la compilation à la place, par exemple le schéma de Staline) et des performances imprévisibles en raison de la dépendance sur des optimisations sophistiquées.

personnellement, j'ai grandi sur les langues dynamiques mais ne les toucherais pas avec un pôle de 40' en tant que professionnel à moins qu'il n'y ait pas d'autres options viables.

De l'Artima en Tapant: Forte vs Faible, Statique vs Dynamique article:

Le

fort typage empêche les opérations de mélange entre des types non appariés. Pour mélanger des types, vous devez utiliser une conversion explicite

faible typage signifie que vous pouvez mélanger des types sans une conversion explicite

dans le journal de Pascal Costanza, Dynamique vs Statique Saisissant Un Modèle d'Analyse Basé sur le (PDF), il affirme que, dans certains cas, le typage statique est plus sujette à des erreurs de typage dynamique. Certains langages statiquement typés vous forcer manuellement émuler typage dynamique afin de faire "La bonne Chose". Il est discuté à Lambda L'ultime .

Cela dépend du contexte. Il y a beaucoup d'avantages qui sont appropriés au système typé dynamique aussi bien que pour Fort typé. Je suis d'avis que le flux du langage des types dynamiques est plus rapide. Les langages dynamiques ne sont pas limités par les attributs de classe et la pensée de compilateur de ce qui se passe dans le code. Vous avez un peu certains de la liberté. En outre, le langage dynamique est généralement plus expressif et entraîne moins de code qui est bon. Malgré cela, il est plus enclin à l'erreur qui est également discutable et dépend davantage de la couverture d'essai de l'unité. C'est un prototype facile avec dynamic lang, mais la maintenance peut devenir un cauchemar.

le principal gain par rapport au système static typed est le support IDE et sûrement l'analyseur statique de code. Vous devenez plus sûr du code après chaque changement de code. Le maintien est la paix du gâteau avec de tels outils.

il y a beaucoup de choses différentes au sujet des langues statiques et dynamiques. Pour moi, la principale différence est que dans les langages dynamiques les variables n'ont pas de types fixes; au lieu de cela, les types sont liés à des valeurs. Pour cette raison, le code exact qui est exécuté est indéterminé jusqu'à l'exécution.

dans les mises en œuvre précoces ou naïves, c'est une énorme perte de performance, mais les JITs modernes se rapprochent de plus en plus du meilleur que vous pouvez obtenir avec l'optimisation des compilateurs statiques. (dans certains cas marginaux, même mieux que cela).

il s'agit du bon outil pour le travail. Ni l'un ni l'autre n'est mieux 100% du temps. Les deux systèmes ont été créés par l'homme et ont des lacunes. Désolé, mais on craint et on fait des trucs parfaits.

j'aime la dactylographie dynamique parce qu'elle sort de mon chemin, mais oui les erreurs d'exécution peuvent monter en flèche que je n'avais pas prévu. Où que la dactylographie statique peut corriger les erreurs susmentionnées, mais conduire un novice(dans les langues dactylographiées) programmeur fou essayant de mouler entre un char constant et une chaîne.

Typage Statique: Les langues telles que Java et Scala sont statiques.

les variables doivent être définies et initialisées avant d'être utilisées dans un code.

pour ex. int x; x = 10;

.hors.println (x);

Typage Dynamique: Perl est un langage dynamique dactylographié.

n'ont pas besoin d'être initialisées avant d'être utilisé dans le code.

y=10; Utilisez cette variable dans la dernière partie du code