Quels sont les arguments en faveur d'un typage faible?

40

Cela a été abordé lors d'une discussion avec un ami et je me suis trouvé dans l'impossibilité de trouver de bons arguments. Quels avantages confère le typage faible?

Fishtoaster
la source
17
Engineering and Compiler, de Cooper et Torczon, définit le typage faible comme utilisant un système de types mal conçu. Cela ne semble certainement pas profiter à quiconque.
Corbin Mars
@Corbin March: Nice one. Je dois ajouter cela à ma liste.
Jörg W Mittag
5
Le meilleur argument peut être avancé par les dirigeants d'entreprise: cela me permet d'embaucher des personnes peu coûteuses pour construire mes systèmes
Vector

Réponses:

46

Le problème avec ce type de discussion est simplement que les termes "typage faible" et "typage fort" ne sont pas définis, contrairement à par exemple les termes "typage statique", "typage dynamique", "typage explicite", "typage implicite", " dactylographie "," typage structural "ou" typage nominal ". Heck, même les termes "typage manifeste" et "typage latent", qui restent des domaines ouverts de recherche et de discussion, sont probablement mieux définis.

Donc, tant que votre ami n’a pas défini le terme "typage faible" suffisamment stable pour pouvoir servir de base à une discussion, il n’a même aucun sens de répondre à cette question.

Malheureusement, mis à part la réponse de Nick , personne n’a pris la peine de donner sa définition non plus, et vous pouvez voir la confusion qui en résulte dans certains des commentaires. C'est difficile à dire, car personne ne fournit réellement leurs définitions, mais je pense en compter au moins trois différentes, rien que sur cette page.

Certaines des définitions les plus couramment utilisées sont (et oui, je sais qu’aucune d’entre elles n’a de sens, mais ce sont les définitions que j’ai déjà vues utiliser):

  • typage faible = typage non sécurisé / typage fort = typage sécurisé
  • typage faible = typage dynamique / typage fort = typage statique
  • typage faible = typage canard / typage fort = typage nominal
  • typage faible = typage structurel / typage fort = typage nominal
  • typage faible = typage implicite / typage fort = typage explicite
  • typage faible = typage latent / typage fort = typage manifeste
  • frappe faible = pas de frappe / frappe forte = frappe
  • typage faible = conversions implicites / typage puissant = uniquement des distributions explicites
  • typage faible = incantations implicites ou explicites / typage fort = pas d'incantation du tout
  • typage faible = conversions implicites / typage fort = uniquement les conversions explicites
  • typage faible = conversions implicites ou explicites / typage fort = pas de conversion du tout
  • typage faible = interprétation / typage fort = compilation
  • typage faible = typage lent / fort = rapide
  • typage faible = récupération de place / typage puissant = gestion manuelle de la mémoire
  • typage faible = gestion manuelle de la mémoire / typage fort = récupération de place
  • … et plein d'autres

Les trois définitions qui semblent être les plus utilisées sont toutefois:

  • typage faible = votre langage de programmation pourri stupide / typage fort = mon langage de programmation super génial
  • typage faible = tout autre langage de programmation / typage fort = le seul langage de programmation que j'ai jamais pris la peine d'apprendre (généralement Java, C # ou C ++; étrangement, les personnes qui apprennent, par exemple, Haskell ou Scheme comme leur premier et unique langage ne semblent pas partager cette vision du monde)
  • typage faible = tous les langages que je ne comprends pas / typage fort = Java (remplace par C # ou C ++ à volonté)

À moins que tout le monde est d' accord sur une définition de « typage faible » , même est , il ne fait même pas de sens de penser à ce que ses avantages pourraient être. Avantages de quoi? Pire encore, s’il n’ya pas de définition du tout , alors tout le monde peut modifier ses définitions pour s’ajuster à ses arguments, et chaque discussion est pratiquement garantie de dégénérer en guerre-flamme.

Personnellement, j’ai moi-même changé plusieurs fois de définition au cours des années et j’ai maintenant atteint le point où je ne considère même plus que les termes sont utiles. J'avais aussi l'habitude de penser que le typage faible (dans ses diverses définitions) avait sa place dans les scripts shell, mais chaque fois que je dois résoudre le même problème dans Bash et PowerShell, je me rappelle douloureusement à quel point je me suis trompé.

Jörg W Mittag
la source
5
Jolie réponse cynique! Je comprends d'où vous venez, mais j'estime qu'il est "assez bon" pour supposer que quiconque ne fournit pas de définition parle de "typage faible et / ou dynamique", c'est pourquoi j'ai inclus les deux dans ma réponse. Je sais que ce n'est pas parfait, mais la plupart des gens semblent ne pas définir les systèmes de types.
Nicole
7
@Renesis: J'appellerais ça du "réalisme" :-) J'ai suffisamment discuté des systèmes de types pour me rendre compte que la moitié des gens ne réalisent pas qu'ils parlent de choses complètement différentes et que les autres ne savent pas de quoi ils parlent à propos du tout . Il y a quelques mois, une discussion a eu lieu sur la liste de développement de base d'un langage que je ne nommerai pas, à propos de l'ajout d'un système de types optionnel pour améliorer les performances. Cette discussion a duré une semaine et a impliqué des dizaines de personnes et des centaines de courriers. Pas un réalisé qu'un système de type en option , par définition , ne peut pas améliorer les performances. …
Jörg W Mittag le
8
+1 pour le cynisme! Vous pouvez ajouter "typage fort = quand l'EDI connaît les types de mes variables (Intellisense etc.), typage faible = quand il ne le sait pas" "
user281377
1
Les noms mieux définis pour les systèmes de dactylographie n'ont pas le jugement de valeur implicite que possèdent les faibles et les forts .
Eva
1
Magnifique, divertissant et précis. Plus j'apprendais sur les systèmes de typage, plus je réalisais combien de temps j'avais souffert sous l'illusion que l'une des langues était différente d'une autre d'une manière qui ne l'était pas du tout. C'est incroyable de voir à quel point ce concept crée de la confusion et je pense vraiment que ce n'est pas nécessaire si seulement nous acceptons que faible / fort n'est pas une chose réelle, parlons donc de quelque chose qui est en réalité et peut-être que nous apprendrons quelque chose.
BrianH
25

N'oubliez pas qu'il existe deux concepts majeurs qui sont souvent confondus:

Frappe dynamique

Un langage de programmation est dit dynamiquement typé lorsque la majorité de sa vérification de type est effectuée au moment de l'exécution, par opposition à la compilation. En typage dynamique, les valeurs ont des types mais pas les variables; c'est-à-dire qu'une variable peut faire référence à une valeur de n'importe quel type.

Les avantages ici sont souvent considérés comme réservés aux "nouveaux" programmeurs, mais peuvent également convenir à tout programmeur:

if (!(arr is Array)) arr = [arr]; // is, instanceof, .constructor ==, whatever

Moins de code dans les cas où vous auriez sinon dû attribuer ou attribuer une nouvelle valeur:

if (data is Array)) {
    i = data.length; // no i = ((Array)data).length or Array myArr=(Array)data;
}

Typage lâche ou faible

Un typage faible signifie qu'un langage convertit (ou convertit) de manière implicite les types lorsqu'il est utilisé.

Avantages:

  • Transmettez une valeur de type en tant que paramètre à une fonction . Utile pour les rappels, les API flexibles et permet une implémentation plus simple des fermetures.
  • Évaluation booléenne implicite . Tout type peut être évalué comme un booléen. Cela présente également des avantages, tels qu'une partie d'un et ||peut être utilisé dans une affectation sans conversion en booléen:

    var a = param || defaultValue;
    
  • Encore une fois, moins de code:

    var num = 5;
    var str = "Hello";
    input.innerHTML = input.value = num;
    for (var i=0; i < input.value; i++) { ... }
    

    Même Java devait aller en partie, avec l'appel implicite à la .toString()combinaison d'objets avec un String; sinon, les programmeurs Java le maudiraient toute la journée (les instructions du journal seraient hors de contrôle).


Les deux définitions proviennent de http://en.wikipedia.org/wiki/Type_system . Il l'a dit mieux que moi.

Nicole
la source
1
Le typage dynamique est également bénéfique là où beaucoup de code devrait être généré dans un langage à typage statique. Comparez la quantité de génération de code nécessaire pour, par exemple, Entity Framework en C # aux bibliothèques ORM dans des langages à typage dynamique (PHP, Python, etc.). Bien que certains puissent affirmer que les avantages en termes d’IDE IntelliSense sont supérieurs au coût de toute cette génération de code ...
Dean Harding
3
Votre commentaire "// no i = (data (Array)) .length ou Array myArr = (Array) data;" n’a vraiment rien à voir avec le typage dynamique, car la richesse des données est prouvable au moment de la compilation. Un langage à typage statique pourrait propager des connaissances obtenues à partir d'instance of.
Peter Taylor
@Peter Taylor, je suppose que c'est vrai dans des cas simples, en connaissez-vous qui le font? Il s’agit du typage dynamique, qu’il s’agisse d’un ifbloc ou d’une autre logique plus complexe (même au moment de l’exécution ou dynamique), la ligne suivante sera licite et exempte d’erreurs.
Nicole
@Renesis, je ne sais pas, non. Mais la famille de langues ML est typée de manière statique et utilise l'inférence de type, il est donc très rare que vous ayez à déclarer explicitement le type d'une variable.
Peter Taylor
1
@Peter Taylor a raison. La plupart des avantages du typage dynamique sont disponibles dans des langues dotées de systèmes de typage statiques plus performants, tels que Haskell, Scala ou même C # dans certains cas. Je dirais que le principal avantage du typage dynamique est de traiter avec des éléments intrinsèquement non typés, comme HTML DOM. Pourquoi écrire node ["attr"] au lieu de node.attr? De toute façon, ils sont toujours résolus au moment de l'exécution.
Matt Olenik le
7

Le principal argument en faveur d'un typage faible est celui de la performance. (Ceci est pour répondre à la question des PO comme indiqué). Il y a beaucoup de bonnes discussions sur dynamique vs statique, implicite vs explicite. etc.

C est le langage le plus célèbre faiblement typé, et il n’effectue aucune vérification à l’exécution ni à la compilation du type de variable. Essentiellement, vous pouvez lancer un char *vers un int *et la langue ne l’intéressera pas. Alors pourquoi feriez-vous cela?

La programmation en C est assez proche de la façon dont vous procéderiez avec un assemblage, il est donc parfois nécessaire de ne se préoccuper que d’une adresse. Il n’est pas rare de donner ou de faire passer une void *référence pour cette raison même. Si vous savez comment la mémoire est organisée (encore une fois un problème de C et d’assemblage), vous pouvez effectuer des calculs assez intéressants en fonction de l’adresse indiquée dans le void *pour obtenir les informations dont vous avez besoin. Cela peut vous permettre de court-circuiter le processus que vous auriez à suivre en Java, par exemple.

Bien que la vérification de type au moment de l’exécution ne génère pas une charge de travail extraordinaire, il arrive parfois qu’elle soit juste suffisante pour que la section critique soit trop lente. Je pense surtout à la programmation intégrée et aux systèmes temps réel dans ce cas.

Cela dit, dans la plupart des cas, avoir un système de type fort contrôlé à la compilation ou à l'exécution aide plus souvent que nécessaire.

Berin Loritsch
la source
2
Je ne vois pas pourquoi un langage fortement typé ne pourrait pas compiler aussi efficacement que C. Mais le compilateur devrait être beaucoup plus complexe.
9000 le
2
C ++ est un exemple d'un tel langage. En C ++, toutes les vérifications de type sont effectuées au moment de la compilation et aucune au moment de l'exécution ... SAUF si RTTI est activé.
Berin Loritsch
2
Pas sûr que je suis d' accord avec cet argument de la performance, mais il est une vue intéressante.
Martin Ba
2

Les utilisateurs débutants ont plus de facilité à saisir les fautes de frappe, par exemple dans Excel, javascript et vbscript. Vous négociez également une vitesse de développement pour des erreurs potentielles.

Bon article sur le sujet: typage fort vs tests forts

Homde
la source
1
Je ne pense pas qu'il y ait une forte correspondance entre les langues faiblement typées et les langues conviviales pour les débutants. Ruby et python sont fortement typés et généralement considérés comme novices. C est faiblement typé et généralement considéré débutant comme hostile.
sepp2k
Non, pas la langue en général, je parlais juste de la dactylographie
Homde
2
Dynamique et fortement typé sont la combinaison conviviale pour les débutants. Bien que j’ai vu que lorsque les gens passent d’un langage à typage statique à un langage à typage dynamique, ils sont également très confus. Cependant, je n'ai jamais vu quelqu'un qui ait commencé avec le typage dynamique depuis que les écoles finissent par enseigner le C ou Java la plupart du temps.
Jsternberg
3
@Mchl: cela n'a rien à voir avec le typage statique / dynamique ou fort / faible. Devoir déclarer des types concerne le typage explicite / implicite.
Jörg W Mittag le
1
Cela pourrait aussi bien être;) Alors je suis aussi passé du langage explicitement au langage implicitement typé. Corrigez-moi si je me trompe. Pascal est typé statiquement, fortement et explicitement, alors que PHP est typé dynamiquement, faiblement et implicitement, n'est-ce pas?
Mchl